public MyFolder GetSpecifiedFolder(string folderpath)
{
MyFolder myfolder = new MyFolder();
myfolder.Path = folderpath;
DirectoryInfo di = new DirectoryInfo(folderpath);
myfolder.Name = di.Name;
myfolder.LastModified = di.LastWriteTimeUtc;
DirectorySecurity sec = di.GetAccessControl();
myfolder.SecurityDesciptor = new Byte[sec.GetSecurityDescriptorBinaryForm().Length];
myfolder.SecurityDesciptor = sec.GetSecurityDescriptorBinaryForm();
return(myfolder);
}
/// <summary>Creates a new directory, ensuring it is created with the specified directory security. If the directory already exists, nothing is done.</summary>
/// <param name="directoryInfo">The object describing a directory that does not exist in disk yet.</param>
/// <param name="directorySecurity">An object that determines the access control and audit security for the directory.</param>
/// <exception cref="ArgumentNullException"><paramref name="directoryInfo" /> or <paramref name="directorySecurity" /> is <see langword="null" />.</exception>
/// <exception cref="DirectoryNotFoundException">Could not find a part of the path.</exception>
/// <exception cref="UnauthorizedAccessException">Access to the path is denied.</exception>
/// <remarks>This extension method was added to .NET Core to bring the functionality that was provided by the `System.IO.DirectoryInfo.Create(System.Security.AccessControl.DirectorySecurity)` .NET Framework method.</remarks>
public static void Create(this DirectoryInfo directoryInfo, DirectorySecurity directorySecurity)
{
ArgumentNullException.ThrowIfNull(directoryInfo);
ArgumentNullException.ThrowIfNull(directorySecurity);
FileSystem.CreateDirectory(directoryInfo.FullName, directorySecurity.GetSecurityDescriptorBinaryForm());
}
private RawSecurityDescriptor CreateSecurityDescriptor(IEnumerable <IdentityRights> allowRights,
IEnumerable <IdentityRights> denyRights = null)
{
var security = new DirectorySecurity();
security.SetOwner(CurrentIdentity);
security.SetGroup(Group);
if (allowRights == null)
{
allowRights = Enumerable.Empty <IdentityRights>();
}
if (denyRights == null)
{
denyRights = Enumerable.Empty <IdentityRights>();
}
foreach (var right in allowRights)
{
security.AddAccessRule(new FileSystemAccessRule(right.Identity, right.Rights,
AccessControlType.Allow));
}
foreach (var right in denyRights)
{
security.AddAccessRule(new FileSystemAccessRule(right.Identity, right.Rights, AccessControlType.Deny));
}
var binaryDescriptor = security.GetSecurityDescriptorBinaryForm();
return(new RawSecurityDescriptor(binaryDescriptor, 0));
}
public void TestCreate()
{
//Arrange
var fs = new MockFileSystem();
var dir = @"c:\my\dir";
//Act
var s = new DirectorySecurity();
var d = s.GetSecurityDescriptorBinaryForm();
_ = new DirectoryActions(fs).Create(dir, 0, d, out var e);
//Assert
Assert.IsTrue(fs.Directory.Exists(@"c:\my\dir"));
Assert.IsTrue(fs.Directory.Exists(@"c:\my\dir"));
Assert.AreEqual(0, e.AllocationSize);
Assert.AreEqual((uint)fs.DirectoryInfo.FromDirectoryName(dir).Attributes, e.Attributes);
Assert.AreEqual(fs.DirectoryInfo.FromDirectoryName(dir).LastWriteTimeUtc.ToFileTimeUtc(), e.ChangeTime);
Assert.AreEqual(fs.DirectoryInfo.FromDirectoryName(dir).CreationTimeUtc.ToFileTimeUtc(), e.CreationTime);
Assert.AreEqual(0, e.EaSize);
Assert.AreEqual(0, e.FileSize);
Assert.AreEqual(0, e.HardLinks);
Assert.AreEqual(0, e.IndexNumber);
Assert.AreEqual(fs.DirectoryInfo.FromDirectoryName(dir).LastAccessTimeUtc.ToFileTimeUtc(), e.LastAccessTime);
Assert.AreEqual(fs.DirectoryInfo.FromDirectoryName(dir).LastWriteTimeUtc.ToFileTimeUtc(), e.LastWriteTime);
Assert.AreEqual(0, e.ReparseTag);
Assert.IsFalse(e.IsFile());
}
public MyFolder[] GetRootFolders()
{
List <MyFolder> myFolders = new List <MyFolder>();
MyFolder myfolder = new MyFolder();
myfolder.Path = this.path;
DirectoryInfo di = new DirectoryInfo(path);
myfolder.Name = di.Name;
myfolder.LastModified = di.LastWriteTimeUtc;
DirectorySecurity sec = di.GetAccessControl();
myfolder.SecurityDesciptor = new Byte[sec.GetSecurityDescriptorBinaryForm().Length];
myfolder.SecurityDesciptor = sec.GetSecurityDescriptorBinaryForm();
myFolders.Add(myfolder);
return(myFolders.ToArray());
}
public MyFolder[] GetSubFolders(string parentFolderPath)
{
List <MyFolder> myFolders = new List <MyFolder>();
foreach (string dirpath in Directory.GetDirectories(parentFolderPath))
{
MyFolder myfolder = new MyFolder();
myfolder.Path = dirpath;
DirectoryInfo di = new DirectoryInfo(dirpath);
myfolder.Name = di.Name;
myfolder.LastModified = di.LastWriteTimeUtc;
DirectorySecurity sec = di.GetAccessControl();
myfolder.SecurityDesciptor = new Byte[sec.GetSecurityDescriptorBinaryForm().Length];
myfolder.SecurityDesciptor = sec.GetSecurityDescriptorBinaryForm();
myFolders.Add(myfolder);
}
return(myFolders.ToArray());
}
public MyFolder GetSpecifiedFolder(string folderpath)
{
if (!Directory.Exists(folderpath))
{
throw new Microsoft.BusinessData.Runtime.ObjectNotFoundException(String.Format(
"No folder exists at the path {0}",
folderpath));
}
MyFolder myfolder = new MyFolder();
myfolder.Path = folderpath;
DirectoryInfo di = new DirectoryInfo(folderpath);
myfolder.Name = di.Name;
myfolder.LastModified = di.LastWriteTimeUtc;
DirectorySecurity sec = di.GetAccessControl();
myfolder.SecurityDescriptor = new Byte[sec.GetSecurityDescriptorBinaryForm().Length];
myfolder.SecurityDescriptor = sec.GetSecurityDescriptorBinaryForm();
return(myfolder);
}
/// <summary>Creates a new directory, ensuring it is created with the specified directory security. If the directory already exists, nothing is done.</summary>
/// <param name="directoryInfo">The object describing a directory that does not exist in disk yet.</param>
/// <param name="directorySecurity">An object that determines the access control and audit security for the directory.</param>
/// <exception cref="ArgumentNullException"><paramref name="directoryInfo" /> or <paramref name="directorySecurity" /> is <see langword="null" />.</exception>
/// <exception cref="DirectoryNotFoundException">Could not find a part of the path.</exception>
/// <exception cref="UnauthorizedAccessException">Access to the path is denied.</exception>
/// <remarks>This extension method was added to .NET Core to bring the functionality that was provided by the `System.IO.DirectoryInfo.Create(System.Security.AccessControl.DirectorySecurity)` .NET Framework method.</remarks>
public static void Create(this DirectoryInfo directoryInfo, DirectorySecurity directorySecurity)
{
if (directoryInfo == null)
{
throw new ArgumentNullException(nameof(directoryInfo));
}
if (directorySecurity == null)
{
throw new ArgumentNullException(nameof(directorySecurity));
}
FileSystem.CreateDirectory(directoryInfo.FullName, directorySecurity.GetSecurityDescriptorBinaryForm());
}
public void GetAccessControl1()
{
string path = Path.Combine(Path.GetTempPath(), "CadruTest");
Directory.CreateDirectory(path);
DirectoryInfo di = new DirectoryInfo(path);
ExtendedDirectoryInfo edi = new ExtendedDirectoryInfo(path);
Assert.IsNotNull(edi);
DirectorySecurity actual = edi.GetAccessControl(AccessControlSections.All);
DirectorySecurity expected = di.GetAccessControl(AccessControlSections.All);
CollectionAssert.AreEqual(expected.GetSecurityDescriptorBinaryForm(), actual.GetSecurityDescriptorBinaryForm());
}
public void TestAccessDenied()
{
string child2 = Path.Combine(TestFolder, @"child1\child2");
DirectorySecurity acl = Directory.GetAccessControl(child2);
byte[] original = acl.GetSecurityDescriptorBinaryForm();
acl.AddAccessRule(
new FileSystemAccessRule(
new SecurityIdentifier(WellKnownSidType.WorldSid, null),
FileSystemRights.ListDirectory,
AccessControlType.Deny)
);
Directory.SetAccessControl(child2, acl);
try
{
//By default it ignores AccessDenied
FindFile ff = new FindFile(child2, "*", false, false);
ff.FileFound += (o, e) => Assert.Fail("Should not find a file");
ff.Find();
//Now raise the AccessDenied
ff.RaiseOnAccessDenied = true;
try
{
ff.Find();
Assert.Fail("Should throw Access Denied.");
}
catch (System.ComponentModel.Win32Exception we)
{ Assert.AreEqual(5, we.NativeErrorCode); }
}
finally
{
acl.SetSecurityDescriptorBinaryForm(original, AccessControlSections.All);
Directory.SetAccessControl(child2, acl);
}
}
public void SetAccessControl()
{
string path = Path.Combine(Path.GetTempPath(), "CadruTest");
Directory.CreateDirectory(path);
DirectoryInfo di = new DirectoryInfo(path);
DirectorySecurity expected = di.GetAccessControl(AccessControlSections.All);
ExtendedDirectoryInfo edi = new ExtendedDirectoryInfo(path);
Assert.IsNotNull(edi);
DirectorySecurity directorySecurity = new DirectorySecurity();
directorySecurity.AddAccessRule(new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, AccessControlType.Allow));
edi.SetAccessControl(directorySecurity);
Assert.AreNotEqual(expected.GetSecurityDescriptorBinaryForm(), edi.GetAccessControl().GetSecurityDescriptorBinaryForm());
DirectorySecurity actualDirectorySecurity = Directory.GetAccessControl(path);
AuthorizationRuleCollection rules = actualDirectorySecurity.GetAccessRules(true, true, typeof(NTAccount));
foreach (AuthorizationRule rule in rules)
{
FileSystemAccessRule accessRule = (FileSystemAccessRule)rule;
if (accessRule.IdentityReference.Value == "Everyone")
{
Assert.IsTrue(accessRule.AccessControlType == AccessControlType.Allow);
Assert.IsTrue(accessRule.FileSystemRights == FileSystemRights.FullControl);
}
}
di.SetAccessControl(expected);
}
private unsafe static void InternalCreateDirectory(String fullPath, String path, Object dirSecurityObj)
{
#if FEATURE_MACL
DirectorySecurity dirSecurity = (DirectorySecurity)dirSecurityObj;
#endif // FEATURE_MACL
int length = fullPath.Length;
// We need to trim the trailing slash or the code will try to create 2 directories of the same name.
if (length >= 2 && Path.IsDirectorySeparator(fullPath[length - 1]))
{
length--;
}
int lengthRoot = LongPath.GetRootLength(fullPath);
#if !PLATFORM_UNIX
// For UNC paths that are only // or ///
if (length == 2 && Path.IsDirectorySeparator(fullPath[1]))
{
throw new IOException(Environment.GetResourceString("IO.IO_CannotCreateDirectory", path));
}
#endif // !PLATFORM_UNIX
List <string> stackDir = new List <string>();
// Attempt to figure out which directories don't exist, and only
// create the ones we need. Note that InternalExists may fail due
// to Win32 ACL's preventing us from seeing a directory, and this
// isn't threadsafe.
bool somepathexists = false;
if (length > lengthRoot)
{ // Special case root (fullpath = X:\\)
int i = length - 1;
while (i >= lengthRoot && !somepathexists)
{
String dir = fullPath.Substring(0, i + 1);
if (!InternalExists(dir)) // Create only the ones missing
{
stackDir.Add(dir);
}
else
{
somepathexists = true;
}
while (i > lengthRoot && fullPath[i] != Path.DirectorySeparatorChar && fullPath[i] != Path.AltDirectorySeparatorChar)
{
i--;
}
i--;
}
}
int count = stackDir.Count;
if (stackDir.Count != 0)
{
String[] securityList = new String[stackDir.Count];
stackDir.CopyTo(securityList, 0);
for (int j = 0; j < securityList.Length; j++)
{
securityList[j] += "\\."; // leaf will never have a slash at the end
}
// Security check for all directories not present only.
#if !FEATURE_PAL && FEATURE_MACL
AccessControlActions control = (dirSecurity == null) ? AccessControlActions.None : AccessControlActions.Change;
new FileIOPermission(FileIOPermissionAccess.Write, control, securityList, false, false).Demand();
#else
new FileIOPermission(FileIOPermissionAccess.Write, securityList, false, false).Demand();
#endif
}
// If we were passed a DirectorySecurity, convert it to a security
// descriptor and set it in he call to CreateDirectory.
Win32Native.SECURITY_ATTRIBUTES secAttrs = null;
#if FEATURE_MACL
if (dirSecurity != null)
{
secAttrs = new Win32Native.SECURITY_ATTRIBUTES();
secAttrs.nLength = (int)Marshal.SizeOf(secAttrs);
// For ACL's, get the security descriptor from the FileSecurity.
byte[] sd = dirSecurity.GetSecurityDescriptorBinaryForm();
byte * bytesOnStack = stackalloc byte[sd.Length];
Buffer.Memcpy(bytesOnStack, 0, sd, 0, sd.Length);
secAttrs.pSecurityDescriptor = bytesOnStack;
}
#endif
bool r = true;
int firstError = 0;
String errorString = path;
// If all the security checks succeeded create all the directories
while (stackDir.Count > 0)
{
String name = stackDir[stackDir.Count - 1];
stackDir.RemoveAt(stackDir.Count - 1);
if (name.Length >= Path.MaxLongPath)
{
throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong"));
}
r = Win32Native.CreateDirectory(Path.AddLongPathPrefix(name), secAttrs);
if (!r && (firstError == 0))
{
int currentError = Marshal.GetLastWin32Error();
// While we tried to avoid creating directories that don't
// exist above, there are at least two cases that will
// cause us to see ERROR_ALREADY_EXISTS here. InternalExists
// can fail because we didn't have permission to the
// directory. Secondly, another thread or process could
// create the directory between the time we check and the
// time we try using the directory. Thirdly, it could
// fail because the target does exist, but is a file.
if (currentError != Win32Native.ERROR_ALREADY_EXISTS)
{
firstError = currentError;
}
else
{
// If there's a file in this directory's place, or if we have ERROR_ACCESS_DENIED when checking if the directory already exists throw.
if (LongPathFile.InternalExists(name) || (!InternalExists(name, out currentError) && currentError == Win32Native.ERROR_ACCESS_DENIED))
{
firstError = currentError;
// Give the user a nice error message, but don't leak path information.
try
{
new FileIOPermission(FileIOPermissionAccess.PathDiscovery, new String[] { GetDemandDir(name, true) }, false, false).Demand();
errorString = name;
}
catch (SecurityException) { }
}
}
}
}
// We need this check to mask OS differences
// Handle CreateDirectory("X:\\foo") when X: doesn't exist. Similarly for n/w paths.
if ((count == 0) && !somepathexists)
{
String root = InternalGetDirectoryRoot(fullPath);
if (!InternalExists(root))
{
// Extract the root from the passed in path again for security.
__Error.WinIOError(Win32Native.ERROR_PATH_NOT_FOUND, InternalGetDirectoryRoot(path));
}
return;
}
// Only throw an exception if creating the exact directory we
// wanted failed to work correctly.
if (!r && (firstError != 0))
{
__Error.WinIOError(firstError, errorString);
}
}
private static unsafe void InternalCreateDirectory(string fullPath, string path, object dirSecurityObj)
{
DirectorySecurity security = (DirectorySecurity)dirSecurityObj;
int length = fullPath.Length;
if ((length >= 2) && Path.IsDirectorySeparator(fullPath[length - 1]))
{
length--;
}
int rootLength = LongPath.GetRootLength(fullPath);
if ((length == 2) && Path.IsDirectorySeparator(fullPath[1]))
{
throw new IOException(Environment.GetResourceString("IO.IO_CannotCreateDirectory", new object[] { path }));
}
List <string> list = new List <string>();
bool flag = false;
if (length > rootLength)
{
for (int i = length - 1; (i >= rootLength) && !flag; i--)
{
string str = fullPath.Substring(0, i + 1);
if (!InternalExists(str))
{
list.Add(str);
}
else
{
flag = true;
}
while (((i > rootLength) && (fullPath[i] != Path.DirectorySeparatorChar)) && (fullPath[i] != Path.AltDirectorySeparatorChar))
{
i--;
}
}
}
int count = list.Count;
if (list.Count != 0)
{
string[] array = new string[list.Count];
list.CopyTo(array, 0);
for (int j = 0; j < array.Length; j++)
{
string[] strArray2;
IntPtr ptr;
(strArray2 = array)[(int)(ptr = (IntPtr)j)] = strArray2[(int)ptr] + @"\.";
}
AccessControlActions control = (security == null) ? AccessControlActions.None : AccessControlActions.Change;
new FileIOPermission(FileIOPermissionAccess.Write, control, array, false, false).Demand();
}
Win32Native.SECURITY_ATTRIBUTES structure = null;
if (security != null)
{
structure = new Win32Native.SECURITY_ATTRIBUTES {
nLength = Marshal.SizeOf(structure)
};
byte[] securityDescriptorBinaryForm = security.GetSecurityDescriptorBinaryForm();
byte * pDest = stackalloc byte[(IntPtr)securityDescriptorBinaryForm.Length];
Buffer.memcpy(securityDescriptorBinaryForm, 0, pDest, 0, securityDescriptorBinaryForm.Length);
structure.pSecurityDescriptor = pDest;
}
bool flag2 = true;
int errorCode = 0;
string maybeFullPath = path;
while (list.Count > 0)
{
string str3 = list[list.Count - 1];
list.RemoveAt(list.Count - 1);
if (str3.Length >= Path.MaxLongPath)
{
throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong"));
}
flag2 = Win32Native.CreateDirectory(Path.AddLongPathPrefix(str3), structure);
if (!flag2 && (errorCode == 0))
{
int lastError = Marshal.GetLastWin32Error();
if (lastError != 0xb7)
{
errorCode = lastError;
}
else if (LongPathFile.InternalExists(str3) || (!InternalExists(str3, out lastError) && (lastError == 5)))
{
errorCode = lastError;
try
{
new FileIOPermission(FileIOPermissionAccess.PathDiscovery, new string[] { GetDemandDir(str3, true) }, false, false).Demand();
maybeFullPath = str3;
continue;
}
catch (SecurityException)
{
continue;
}
}
}
}
if ((count == 0) && !flag)
{
if (!InternalExists(InternalGetDirectoryRoot(fullPath)))
{
__Error.WinIOError(3, InternalGetDirectoryRoot(path));
}
}
else if (!flag2 && (errorCode != 0))
{
__Error.WinIOError(errorCode, maybeFullPath);
}
}
private unsafe static void InternalCreateDirectory(string fullPath, string path, object dirSecurityObj)
{
DirectorySecurity directorySecurity = (DirectorySecurity)dirSecurityObj;
int num = fullPath.Length;
if (num >= 2 && Path.IsDirectorySeparator(fullPath[num - 1]))
{
num--;
}
int rootLength = LongPath.GetRootLength(fullPath);
if (num == 2 && Path.IsDirectorySeparator(fullPath[1]))
{
throw new IOException(Environment.GetResourceString("IO.IO_CannotCreateDirectory", new object[]
{
path
}));
}
List <string> list = new List <string>();
bool flag = false;
if (num > rootLength)
{
int num2 = num - 1;
while (num2 >= rootLength && !flag)
{
string text = fullPath.Substring(0, num2 + 1);
if (!LongPathDirectory.InternalExists(text))
{
list.Add(text);
}
else
{
flag = true;
}
while (num2 > rootLength && fullPath[num2] != Path.DirectorySeparatorChar && fullPath[num2] != Path.AltDirectorySeparatorChar)
{
num2--;
}
num2--;
}
}
int count = list.Count;
if (list.Count != 0 && !CodeAccessSecurityEngine.QuickCheckForAllDemands())
{
string[] array = new string[list.Count];
list.CopyTo(array, 0);
for (int i = 0; i < array.Length; i++)
{
string[] array2 = array;
int num3 = i;
array2[num3] += "\\.";
}
AccessControlActions control = (directorySecurity == null) ? AccessControlActions.None : AccessControlActions.Change;
FileIOPermission.QuickDemand(FileIOPermissionAccess.Write, control, array, false, false);
}
Win32Native.SECURITY_ATTRIBUTES security_ATTRIBUTES = null;
if (directorySecurity != null)
{
security_ATTRIBUTES = new Win32Native.SECURITY_ATTRIBUTES();
security_ATTRIBUTES.nLength = Marshal.SizeOf <Win32Native.SECURITY_ATTRIBUTES>(security_ATTRIBUTES);
byte[] securityDescriptorBinaryForm = directorySecurity.GetSecurityDescriptorBinaryForm();
byte * ptr = stackalloc byte[checked (unchecked ((UIntPtr)securityDescriptorBinaryForm.Length) * 1)];
Buffer.Memcpy(ptr, 0, securityDescriptorBinaryForm, 0, securityDescriptorBinaryForm.Length);
security_ATTRIBUTES.pSecurityDescriptor = ptr;
}
bool flag2 = true;
int num4 = 0;
string maybeFullPath = path;
while (list.Count > 0)
{
string text2 = list[list.Count - 1];
list.RemoveAt(list.Count - 1);
if (text2.Length >= 32767)
{
throw new PathTooLongException(Environment.GetResourceString("IO.PathTooLong"));
}
flag2 = Win32Native.CreateDirectory(PathInternal.EnsureExtendedPrefix(text2), security_ATTRIBUTES);
if (!flag2 && num4 == 0)
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != 183)
{
num4 = lastWin32Error;
}
else if (LongPathFile.InternalExists(text2) || (!LongPathDirectory.InternalExists(text2, out lastWin32Error) && lastWin32Error == 5))
{
num4 = lastWin32Error;
try
{
FileIOPermission.QuickDemand(FileIOPermissionAccess.PathDiscovery, LongPathDirectory.GetDemandDir(text2, true), false, false);
maybeFullPath = text2;
}
catch (SecurityException)
{
}
}
}
}
if (count == 0 && !flag)
{
string path2 = LongPathDirectory.InternalGetDirectoryRoot(fullPath);
if (!LongPathDirectory.InternalExists(path2))
{
__Error.WinIOError(3, LongPathDirectory.InternalGetDirectoryRoot(path));
}
return;
}
if (!flag2 && num4 != 0)
{
__Error.WinIOError(num4, maybeFullPath);
}
}
public void Create()
{
FileShareWitnessCheckResult fileShareWitnessCheckResult = this.Check();
if (fileShareWitnessCheckResult != FileShareWitnessCheckResult.FswOK)
{
FileSystemSecurity fileSystemSecurity = new DirectorySecurity();
foreach (FileSystemAccessRule rule in this.AccessRules)
{
fileSystemSecurity.AddAccessRule(rule);
}
switch (fileShareWitnessCheckResult)
{
case FileShareWitnessCheckResult.FswDoesNotExist:
try
{
TaskLogger.Trace("Attempting to create new witness share \\\\{0}\\{1}.", new object[]
{
this.WitnessServer,
this.ShareName
});
WmiWrapper.CreateDirectory(this.WitnessServerFqdn, this.WitnessDirectory.ToString());
int num;
NetShare.AddShare(string.Format(FileShareWitness.s_hostNameFormat, this.WitnessServerFqdn), null, this.ShareName, this.WitnessDirectory.ToString(), this.m_shareRemark, fileSystemSecurity.GetSecurityDescriptorBinaryForm(), out num);
this.m_existingShareRemark = this.m_shareRemark;
this.m_shareType = 0U;
this.m_sharePermissions = 1;
this.m_shareMaxUses = -1;
this.m_existingWitnessDirectory = this.WitnessDirectory;
this.m_existingSecurity = fileSystemSecurity;
this.m_exists = new bool?(true);
this.m_isJustCreated = true;
TaskLogger.Trace("Attempt to create new witness share \\\\{0}\\{1} succeeded.", new object[]
{
this.WitnessServer,
this.ShareName
});
return;
}
catch (WmiException ex)
{
throw new DagFswUnableToCreateWitnessDirectoryException(this.WitnessServerFqdn, this.WitnessDirectory.ToString(), ex);
}
catch (Win32Exception ex2)
{
throw new DagFswUnableToCreateWitnessShareException(this.WitnessServerFqdn, this.FileShareWitnessShare.ToString(), ex2);
}
break;
case FileShareWitnessCheckResult.FswWrongDirectory:
goto IL_1C1;
case FileShareWitnessCheckResult.FswWrongPermissions:
break;
default:
return;
}
fileSystemSecurity = this.m_existingSecurity;
foreach (FileSystemAccessRule rule2 in this.AccessRules)
{
fileSystemSecurity.AddAccessRule(rule2);
}
try
{
IL_1C1:
TaskLogger.Trace("Attempting to modify permissions on witness share \\\\{0}\\{1}.", new object[]
{
this.WitnessServer,
this.ShareName
});
NetShare.SetShareInfo(this.WitnessServerFqdn, this.ShareName, this.WitnessDirectory.ToString(), this.m_shareRemark, this.m_shareType, this.m_sharePermissions, -1, fileSystemSecurity.GetSecurityDescriptorBinaryForm());
this.m_existingWitnessDirectory = this.WitnessDirectory;
this.m_existingSecurity = fileSystemSecurity;
this.m_shareMaxUses = -1;
this.m_exists = new bool?(true);
TaskLogger.Trace("Attempt to modify permissions on witness share \\\\{0}\\{1} succeeded.", new object[]
{
this.WitnessServer,
this.ShareName
});
}
catch (Win32Exception ex3)
{
throw new DagFswUnableToUpdateWitnessShareException(this.WitnessServerFqdn, this.FileShareWitnessShare.ToString(), ex3);
}
}
}
