private static NativeMethods.SECURITY_INFORMATION ToSecurityInfo(PreserveSMBPermissions preserveSMBPermissions)
{
uint securityInfo = 0;
if (PreserveSMBPermissions.Owner == (preserveSMBPermissions & PreserveSMBPermissions.Owner))
{
securityInfo |= (uint)NativeMethods.SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION;
}
if (PreserveSMBPermissions.Group == (preserveSMBPermissions & PreserveSMBPermissions.Group))
{
securityInfo |= (uint)NativeMethods.SECURITY_INFORMATION.GROUP_SECURITY_INFORMATION;
}
if (PreserveSMBPermissions.DACL == (preserveSMBPermissions & PreserveSMBPermissions.DACL))
{
securityInfo |= (uint)NativeMethods.SECURITY_INFORMATION.DACL_SECURITY_INFORMATION;
}
if (PreserveSMBPermissions.SACL == (preserveSMBPermissions & PreserveSMBPermissions.SACL))
{
securityInfo |= (uint)NativeMethods.SECURITY_INFORMATION.SACL_SECURITY_INFORMATION;
}
return((NativeMethods.SECURITY_INFORMATION)(securityInfo));
}
public static void SetFileSecurityInfo(string path, string portableSDDL, PreserveSMBPermissions preserveSMBPermissions)
{
try
{
path = DMLibTestConstants.SupportUNCPath ?
LongPath.GetFullPath(LongPath.ToUncPath(path)) :
LongPath.GetFullPath(path);
}
catch (Exception)
{ }
FileSecurityOperations.SetFileSecurity(path, portableSDDL, preserveSMBPermissions);
}
/// <summary>
/// Restore privileges enabled before for getting/setting local file permissions.
/// </summary>
/// <param name="preserveSMBPermissions">Permissions types to be preserved.</param>
/// <param name="setLocalFilePermission">Indicating whether to set permission to local file.
/// Setting owner info to local file would need specific privilege, while getting owner info doesn't require this privilege.</param>
public static void RestorePrivileges(PreserveSMBPermissions preserveSMBPermissions, bool setLocalFilePermission)
{
if (PreserveSMBPermissions.SACL == (preserveSMBPermissions & PreserveSMBPermissions.SACL))
{
if (!SACLPrivilegeEnabledOriginal)
{
try
{
SetPrivilege(FileSecurityNativeMethods.SACLPrivilegeName, false);
}
catch (Win32Exception)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
catch (COMException)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
}
}
if (!setLocalFilePermission)
{
return;
}
if (PreserveSMBPermissions.Owner == (preserveSMBPermissions & PreserveSMBPermissions.Owner))
{
if (!OwnerPrivilegeEnabledOriginal)
{
try
{
SetPrivilege(FileSecurityNativeMethods.OwnerPrivilegeName, false);
}
catch (Win32Exception)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
catch (COMException)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
}
}
}
public static string GetFilePortableSDDL(string path, PreserveSMBPermissions preserveSMBPermissions)
{
try
{
path = DMLibTestConstants.SupportUNCPath ?
LongPath.GetFullPath(LongPath.ToUncPath(path)) :
LongPath.GetFullPath(path);
}
catch (Exception)
{ }
return(FileSecurityOperations.GetFilePortableSDDL(path, preserveSMBPermissions));
}
public static void SetFileSecurity(string filePath, string portableSDDL, PreserveSMBPermissions preserveSMBPermissions)
{
if (PreserveSMBPermissions.None == preserveSMBPermissions)
{
return;
}
if (string.IsNullOrEmpty(portableSDDL))
{
return;
}
IntPtr pSecurityDescriptor = new IntPtr();
UIntPtr securityDescriptorLength = new UIntPtr();
if (!FileSecurityNativeMethods.ConvertStringSecurityDescriptorToSecurityDescriptor(portableSDDL,
FileSecurityNativeMethods.SDDL_REVISION_1,
out pSecurityDescriptor,
out securityDescriptorLength))
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
try
{
FileSecurityNativeMethods.SetFileSecurity(filePath,
(int)(ToSecurityInfo(preserveSMBPermissions)),
pSecurityDescriptor);
int errorCode = Marshal.GetLastWin32Error();
int hresult = Marshal.GetHRForLastWin32Error();
if ((errorCode == FileSecurityNativeMethods.ERROR_PRIVILEGE_NOT_HELD) ||
(errorCode == FileSecurityNativeMethods.ERROR_ACCESS_DENIED) ||
(errorCode == FileSecurityNativeMethods.ERROR_INVALID_OWNER))
{
throw new Win32Exception(errorCode);
}
if (errorCode != 0)
{
Marshal.ThrowExceptionForHR(hresult);
}
}
finally
{
FileSecurityNativeMethods.LocalFree(pSecurityDescriptor);
}
}
public static string GetFilePortableSDDL(
string filePath,
PreserveSMBPermissions preserveSMBPermissions)
{
if (preserveSMBPermissions == PreserveSMBPermissions.None)
{
return(null);
}
string sddl = GetFileSDDL(filePath, ToSecurityInfo(preserveSMBPermissions));
string userName = GetUserName();
string domainSid = GetDomainSid(userName);
return(GetPortableSDDL(sddl, domainSid));
}
/// <summary>
/// Enable privileges required for getting/setting premissions from/to local file.
/// </summary>
/// <param name="preserveSMBPermissions">Permissions types to be preserved.</param>
/// <param name="setLocalFilePermission">Indicating whether to set permission to local file.
/// Setting owner info to local file would need specific privilege, while getting owner info doesn't require this privilege.</param>
public static void EnableRequiredPrivileges(PreserveSMBPermissions preserveSMBPermissions, bool setLocalFilePermission)
{
if (PreserveSMBPermissions.SACL == (preserveSMBPermissions & PreserveSMBPermissions.SACL))
{
if (!SACLPrivilegeEnabledOriginal)
{
try
{
SACLPrivilegeEnabledOriginal = SetPrivilege(FileSecurityNativeMethods.SACLPrivilegeName, true);
}
catch (Exception)
{
throw;
}
}
}
if (!setLocalFilePermission)
{
return;
}
if (PreserveSMBPermissions.Owner == (preserveSMBPermissions & PreserveSMBPermissions.Owner))
{
if (!OwnerPrivilegeEnabledOriginal)
{
try
{
OwnerPrivilegeEnabledOriginal = SetPrivilege(FileSecurityNativeMethods.OwnerPrivilegeName, true);
}
catch (COMException)
{
// Ignore exception here
// Under some condition, setting owner info to local file will still success even when there's no SeRestorePrivilege privilege.
// So here only try to enable the privilege. Later, if it fails to set owner info to local file, reports error for the specific file.
return;
}
catch (TransferException)
{
// Ignore exception here
// Under some condition, setting owner info to local file will still success even when there's no SeRestorePrivilege privilege.
// So here only try to enable the privilege. Later, if it fails to set owner info to local file, reports error for the specific file.
return;
}
}
}
}
public static string GetFilePortableSDDL(
string filePath,
PreserveSMBPermissions preserveSMBPermissions)
{
#if DEBUG
if (null != TestHookCallbacks.GetFilePermissionsCallback)
{
return(TestHookCallbacks.GetFilePermissionsCallback(filePath, preserveSMBPermissions));
}
#endif
if (preserveSMBPermissions == PreserveSMBPermissions.None)
{
return(null);
}
string sddl = GetFileSDDL(filePath, ToSecurityInfo(preserveSMBPermissions));
string userName = GetUserName();
string domainSid = GetDomainSid(userName);
return(GetPortableSDDL(sddl, domainSid));
}
public void TestDirectoryPreserveSMBPermissionsResume()
{
if (!CrossPlatformHelpers.IsWindows)
{
return;
}
PreserveSMBPermissions preserveSMBPermissions =
PreserveSMBPermissions.Owner
| PreserveSMBPermissions.Group
| PreserveSMBPermissions.DACL;
string sampleSDDL = "O:S-1-5-21-2146773085-903363285-719344707-1375029G:S-1-5-21-2146773085-903363285-719344707-513D:(A;ID;FA;;;BA)(A;OICIIOID;GA;;;BA)(A;ID;FA;;;SY)(A;OICIIOID;GA;;;SY)(A;ID;0x1301bf;;;AU)(A;OICIIOID;SDGXGWGR;;;AU)(A;ID;0x1200a9;;;BU)(A;OICIIOID;GXGR;;;BU)";
CancellationTokenSource tokenSource = new CancellationTokenSource();
TransferItem transferItem = null;
bool IsStreamJournal = random.Next(0, 2) == 0;
using (Stream journalStream = new MemoryStream())
{
// Prepare data
DMLibDataInfo sourceDataInfo = new DMLibDataInfo("");
GenerateDirNodeWithPermissions(sourceDataInfo.RootNode, 2, sampleSDDL);
DirectoryTransferContext dirTransferContext = null;
if (IsStreamJournal)
{
dirTransferContext = new DirectoryTransferContext(journalStream);
}
else
{
dirTransferContext = new DirectoryTransferContext();
}
var progressChecker = new ProgressChecker(14, 14 * 1024);
dirTransferContext.ProgressHandler = progressChecker.GetProgressHandler();
var options = new TestExecutionOptions <DMLibDataInfo>();
options.IsDirectoryTransfer = true;
options.TransferItemModifier = (fileNode, item) =>
{
item.TransferContext = dirTransferContext;
dynamic transferOptions = DefaultTransferDirectoryOptions;
transferOptions.Recursive = true;
transferOptions.PreserveSMBPermissions = preserveSMBPermissions;
item.Options = transferOptions;
item.CancellationToken = tokenSource.Token;
transferItem = item;
};
TransferCheckpoint checkpoint = null;
options.AfterAllItemAdded = () =>
{
// Wait until there are data transferred
progressChecker.DataTransferred.WaitOne();
if (!IsStreamJournal)
{
checkpoint = dirTransferContext.LastCheckpoint;
}
// Cancel the transfer and store the second checkpoint
tokenSource.Cancel();
};
#if DEBUG
TestHookCallbacks.UnderTesting = true;
TestHookCallbacks.GetFilePermissionsCallback = (path, SMBPermissionType) =>
{
Test.Assert(SMBPermissionType == preserveSMBPermissions, "The SMB permission type should be expected.");
return(sampleSDDL);
};
TestHookCallbacks.SetFilePermissionsCallback = (path, portableSDDL, SMBPermissionType) =>
{
Test.Assert(SMBPermissionType == preserveSMBPermissions, "The SMB permission type should be expected.");
Test.Assert(portableSDDL.StartsWith(sampleSDDL),
"The SDDL value should be expected.");
};
#endif
try
{
// Execute test case
var result = this.ExecuteTestCase(sourceDataInfo, options);
Test.Assert(result.Exceptions.Count == 1, "Verify job is cancelled");
Exception exception = result.Exceptions[0];
Helper.VerifyCancelException(exception);
TransferItem resumeItem = transferItem.Clone();
DirectoryTransferContext resumeContext = null;
journalStream.Position = 0;
if (IsStreamJournal)
{
resumeContext = new DirectoryTransferContext(journalStream);
}
else
{
resumeContext = new DirectoryTransferContext(DMLibTestHelper.RandomReloadCheckpoint(checkpoint));
}
resumeItem.TransferContext = resumeContext;
result = this.RunTransferItems(new List <TransferItem>()
{
resumeItem
}, new TestExecutionOptions <DMLibDataInfo>());
VerificationHelper.VerifyTransferSucceed(result, sourceDataInfo);
if (DMLibTestContext.DestType == DMLibDataType.CloudFile)
{
Helper.CompareSMBPermissions(sourceDataInfo.RootNode, result.DataInfo.RootNode, preserveSMBPermissions);
}
}
finally
{
#if DEBUG
TestHookCallbacks.UnderTesting = false;
TestHookCallbacks.GetFilePermissionsCallback = null;
TestHookCallbacks.SetFilePermissionsCallback = null;
#endif
}
}
}
public void TestPreserveSMBPermissions()
{
if (!CrossPlatformHelpers.IsWindows)
{
return;
}
try
{
PreserveSMBPermissions preserveSMBPermissions =
PreserveSMBPermissions.Owner
| PreserveSMBPermissions.Group
| PreserveSMBPermissions.DACL;
string sampleSDDL = "O:S-1-5-21-2146773085-903363285-719344707-1375029G:S-1-5-21-2146773085-903363285-719344707-513D:(A;ID;FA;;;BA)(A;OICIIOID;GA;;;BA)(A;ID;FA;;;SY)(A;OICIIOID;GA;;;SY)(A;ID;0x1301bf;;;AU)(A;OICIIOID;SDGXGWGR;;;AU)(A;ID;0x1200a9;;;BU)(A;OICIIOID;GXGR;;;BU)";
#if DEBUG
TestHookCallbacks.UnderTesting = true;
TestHookCallbacks.GetFilePermissionsCallback = (path, SMBPermissionType) =>
{
Test.Assert(SMBPermissionType == preserveSMBPermissions, "The SMB permission type should be expected.");
return(sampleSDDL);
};
TestHookCallbacks.SetFilePermissionsCallback = (path, portableSDDL, SMBPermissionType) =>
{
Test.Assert(SMBPermissionType == preserveSMBPermissions, "The SMB permission type should be expected.");
Test.Assert(portableSDDL.StartsWith(sampleSDDL),
"The SDDL value should be expected.");
};
#endif
// Prepare data
DMLibDataInfo sourceDataInfo = new DMLibDataInfo("");
FileNode fileNode = new FileNode(DMLibTestBase.FileName);
fileNode.SizeInByte = 1024;
fileNode.PortableSDDL = sampleSDDL;
sourceDataInfo.RootNode.AddFileNode(fileNode);
SingleTransferContext transferContext = new SingleTransferContext();
var options = new TestExecutionOptions <DMLibDataInfo>();
options.TransferItemModifier = (fileNodeVar, transferItem) =>
{
transferItem.TransferContext = transferContext;
dynamic transferOptions = DefaultTransferOptions;
transferOptions.PreserveSMBPermissions = preserveSMBPermissions;
transferItem.Options = transferOptions;
};
// Execute test case
var result = this.ExecuteTestCase(sourceDataInfo, options);
VerificationHelper.VerifyTransferSucceed(result, sourceDataInfo);
if (DMLibTestContext.DestType == DMLibDataType.CloudFile)
{
Helper.CompareSMBPermissions(sourceDataInfo.RootNode, result.DataInfo.RootNode, preserveSMBPermissions);
}
}
finally
{
#if DEBUG
TestHookCallbacks.UnderTesting = false;
TestHookCallbacks.GetFilePermissionsCallback = null;
TestHookCallbacks.SetFilePermissionsCallback = null;
#endif
}
}
private void GenerateFile(FileNode fileNode, string parentPath, bool handleSMBAttributes = false, PreserveSMBPermissions getPermissions = PreserveSMBPermissions.None)
{
this.CheckFileNode(fileNode);
string localFilePath = Path.Combine(parentPath, fileNode.Name);
DMLibDataHelper.CreateLocalFile(fileNode, localFilePath);
if (handleSMBAttributes)
{
LongPathFileExtension.SetAttributes(localFilePath, Helper.ToFileAttributes(fileNode.SMBAttributes.Value));
}
#if DOTNET5_4
FileInfo fileInfo = new FileInfo(localFilePath);
this.BuildFileNode(fileInfo, fileNode, handleSMBAttributes, getPermissions);
#else
this.BuildFileNode(localFilePath, fileNode, handleSMBAttributes, getPermissions);
#endif
}
/// <summary>
/// This method should be invoked at the end of transfer job handling, to disable privileges which are enabled at the beginning of the transfer job.
/// Getting/setting premissions from/to local file may need some specific privileges.
/// These privileges should be enabled at the beginning of a transfer job, and disbled at the end of the transfer job.
/// </summary>
/// <param name="preserveSMBPermissions">Permissions types to be preserved.</param>
/// <param name="setLocalFilePermission">Indicating whether to set permission to local file.
/// Setting owner info to local file would need specific privilege, while getting owner info doesn't require this privilege.</param>
public static void EnableRequiredPrivileges(PreserveSMBPermissions preserveSMBPermissions, bool setLocalFilePermission)
{
#if DEBUG
if (TestHookCallbacks.UnderTesting)
{
return;
}
#endif
if (PreserveSMBPermissions.SACL == (preserveSMBPermissions & PreserveSMBPermissions.SACL))
{
if (!SACLPrivilegeEnabledOriginal)
{
lock (SACLPrivilegeLock)
{
if (SACLPrivilegeEnabledOriginal)
{
return;
}
++SACLPrivilegeJobCount;
if (SACLPrivilegeEnabled)
{
return;
}
try
{
SACLPrivilegeEnabledOriginal = SetPrivilege(NativeMethods.SACLPrivilegeName, true);
}
catch (Exception)
{
--SACLPrivilegeJobCount;
throw;
}
SACLPrivilegeEnabled = true;
if (SACLPrivilegeEnabledOriginal)
{
--SACLPrivilegeJobCount;
}
}
}
}
if (!setLocalFilePermission)
{
return;
}
if (PreserveSMBPermissions.Owner == (preserveSMBPermissions & PreserveSMBPermissions.Owner))
{
if (!OwnerPrivilegeEnabledOriginal)
{
lock (OwnerPrivilegeLock)
{
if (OwnerPrivilegeEnabledOriginal)
{
return;
}
++OwnerPrivilegeJobCount;
if (OwnerPrivilegeEnabled)
{
return;
}
try
{
OwnerPrivilegeEnabledOriginal = SetPrivilege(NativeMethods.OwnerPrivilegeName, true);
}
catch (COMException)
{
// Ignore exception here
// Under some condition, setting owner info to local file will still success even when there's no SeRestorePrivilege privilege.
// So here only try to enable the privilege. Later, if it fails to set owner info to local file, reports error for the specific file.
--OwnerPrivilegeJobCount;
return;
}
catch (TransferException)
{
// Ignore exception here
// Under some condition, setting owner info to local file will still success even when there's no SeRestorePrivilege privilege.
// So here only try to enable the privilege. Later, if it fails to set owner info to local file, reports error for the specific file.
--OwnerPrivilegeJobCount;
return;
}
OwnerPrivilegeEnabled = true;
if (OwnerPrivilegeEnabledOriginal)
{
--OwnerPrivilegeJobCount;
}
}
}
}
}
public static void SetFileSecurity(string filePath, string portableSDDL, PreserveSMBPermissions preserveSMBPermissions)
{
#if DEBUG
if (null != TestHookCallbacks.SetFilePermissionsCallback)
{
TestHookCallbacks.SetFilePermissionsCallback(filePath, portableSDDL, preserveSMBPermissions);
return;
}
#endif
filePath = LongPath.ToUncPath(filePath);
if (PreserveSMBPermissions.None == preserveSMBPermissions)
{
return;
}
if (string.IsNullOrEmpty(portableSDDL))
{
return;
}
IntPtr pSecurityDescriptor = new IntPtr();
UIntPtr securityDescriptorLength = new UIntPtr();
if (!NativeMethods.ConvertStringSecurityDescriptorToSecurityDescriptor(portableSDDL,
NativeMethods.SDDL_REVISION_1,
out pSecurityDescriptor,
out securityDescriptorLength))
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
try
{
NativeMethods.SetFileSecurity(filePath,
(int)(ToSecurityInfo(preserveSMBPermissions)),
pSecurityDescriptor);
int errorCode = Marshal.GetLastWin32Error();
int hresult = Marshal.GetHRForLastWin32Error();
if ((errorCode == NativeMethods.ERROR_PRIVILEGE_NOT_HELD) ||
(errorCode == NativeMethods.ERROR_ACCESS_DENIED) ||
(errorCode == NativeMethods.ERROR_INVALID_OWNER))
{
#if !DMLIB_TEST
string privilegeName = null;
if ((preserveSMBPermissions & PreserveSMBPermissions.Owner) == PreserveSMBPermissions.Owner)
{
privilegeName = NativeMethods.OwnerPrivilegeName;
}
if ((preserveSMBPermissions & PreserveSMBPermissions.SACL) == PreserveSMBPermissions.SACL)
{
if (null == privilegeName)
{
privilegeName = NativeMethods.SACLPrivilegeName;
}
else
{
privilegeName += " ";
privilegeName += NativeMethods.SACLPrivilegeName;
}
}
if (null != privilegeName)
{
throw new TransferException(
string.Format(
CultureInfo.CurrentCulture,
Resources.PrivilegeRequiredException,
privilegeName));
}
#else
throw new Win32Exception(errorCode);
#endif
}
if (errorCode != 0)
{
Marshal.ThrowExceptionForHR(hresult);
}
}
finally
{
NativeMethods.LocalFree(pSecurityDescriptor);
}
}
/// <summary>
/// This method should be invoked at the end of transfer job handling, to disable privileges which are enabled at the beginning of the transfer job.
/// Getting/setting premissions from/to local file may need some specific privileges.
/// These privileges should be enabled at the beginning of a transfer job, and disbled at the end of the transfer job.
/// </summary>
/// <param name="preserveSMBPermissions">Permissions types to be preserved.</param>
/// <param name="setLocalFilePermission">Indicating whether to set permission to local file.
/// Setting owner info to local file would need specific privilege, while getting owner info doesn't require this privilege.</param>
public static void DisablePrivileges(PreserveSMBPermissions preserveSMBPermissions, bool setLocalFilePermission)
{
#if DEBUG
if (TestHookCallbacks.UnderTesting)
{
return;
}
#endif
if (PreserveSMBPermissions.SACL == (preserveSMBPermissions & PreserveSMBPermissions.SACL))
{
if (!SACLPrivilegeEnabledOriginal)
{
lock (SACLPrivilegeLock)
{
if (SACLPrivilegeEnabledOriginal)
{
return;
}
--SACLPrivilegeJobCount;
if (0 == SACLPrivilegeJobCount)
{
try
{
SetPrivilege(NativeMethods.SACLPrivilegeName, false);
}
catch (TransferException)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
catch (COMException)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
SACLPrivilegeEnabled = false;
}
}
}
}
if (!setLocalFilePermission)
{
return;
}
if (PreserveSMBPermissions.Owner == (preserveSMBPermissions & PreserveSMBPermissions.Owner))
{
if (!OwnerPrivilegeEnabledOriginal)
{
lock (OwnerPrivilegeLock)
{
if (!OwnerPrivilegeEnabled ||
OwnerPrivilegeEnabledOriginal)
{
return;
}
--OwnerPrivilegeJobCount;
if (0 == OwnerPrivilegeJobCount)
{
try
{
SetPrivilege(NativeMethods.OwnerPrivilegeName, false);
}
catch (TransferException)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
catch (COMException)
{
// Ignore the exception
// Here just try to clear up the privileges which may have been enabled at the very beginning of a tranfer job.
// Failure on disabling the privilege won't impact transfer result.
}
OwnerPrivilegeEnabled = false;
}
}
}
}
}
private void BuildDirNode(DirectoryInfo dirInfo, DirNode parent, bool handleSMBAttributes = false, PreserveSMBPermissions preserveSMBPermissions = PreserveSMBPermissions.None)
{
DateTimeOffset?creationTime = null;
DateTimeOffset?lastWriteTime = null;
FileAttributes?fileAttributes = null;
#if DOTNET5_4
LongPathFileExtension.GetFileProperties(dirInfo.FullName, out creationTime, out lastWriteTime, out fileAttributes, true);
#else
LongPathFileExtension.GetFileProperties(dirInfo.FullName, out creationTime, out lastWriteTime, out fileAttributes);
#endif
parent.CreationTime = creationTime;
parent.LastWriteTime = lastWriteTime;
foreach (FileInfo fileInfo in dirInfo.GetFiles())
{
FileNode fileNode = new FileNode(fileInfo.Name);
this.BuildFileNode(fileInfo, fileNode, handleSMBAttributes, preserveSMBPermissions);
parent.AddFileNode(fileNode);
}
foreach (DirectoryInfo subDirInfo in dirInfo.GetDirectories())
{
DirNode subDirNode = new DirNode(subDirInfo.Name);
this.BuildDirNode(subDirInfo, subDirNode, handleSMBAttributes, preserveSMBPermissions);
parent.AddDirNode(subDirNode);
}
}
private void GenerateDir(DirNode dirNode, string parentPath, bool handleSMBAttributes = false, PreserveSMBPermissions getPermissions = PreserveSMBPermissions.None)
{
string dirPath = Path.Combine(parentPath, dirNode.Name);
if (!string.IsNullOrEmpty(dirNode.Content))
{
CreateSymlink(dirPath, dirNode.Content);
Test.Info("Building symlinked dir info of {0}", dirPath);
dirNode.BuildSymlinkedDirNode();
return;
}
DMLibDataHelper.CreateLocalDirIfNotExists(dirPath);
foreach (var file in dirNode.FileNodes)
{
GenerateFile(file, dirPath, handleSMBAttributes, getPermissions);
}
foreach (var subDir in dirNode.NormalDirNodes)
{
GenerateDir(subDir, dirPath, handleSMBAttributes, getPermissions);
}
foreach (var subDir in dirNode.SymlinkedDirNodes)
{
CreateSymlink(Path.Combine(dirPath, subDir.Name), subDir.Content);
Test.Info("Building symlinked dir info of {0}", Path.Combine(dirPath, subDir.Name));
subDir.BuildSymlinkedDirNode();
}
}
public static string GetFilePortableSDDL(string path, PreserveSMBPermissions preserveSMBPermissions)
{
return(FileSecurityOperations.GetFilePortableSDDL(path, preserveSMBPermissions));
}
private void BuildDirNode(string dirPath, DirNode parent, bool handleSMBAttributes, PreserveSMBPermissions getSMBPermissions)
{
dirPath = AppendDirectorySeparator(dirPath);
DateTimeOffset?creationTime = null;
DateTimeOffset?lastWriteTime = null;
FileAttributes?fileAttributes = null;
#if DOTNET5_4
LongPathFileExtension.GetFileProperties(dirPath, out creationTime, out lastWriteTime, out fileAttributes, true);
#else
LongPathFileExtension.GetFileProperties(dirPath, out creationTime, out lastWriteTime, out fileAttributes);
#endif
parent.CreationTime = creationTime;
parent.LastWriteTime = lastWriteTime;
if (PreserveSMBPermissions.None != getSMBPermissions)
{
parent.PortableSDDL = LongPathFileExtension.GetFilePortableSDDL(dirPath, getSMBPermissions);
}
foreach (var fileInfo in LongPathDirectoryExtension.GetFiles(dirPath))
{
FileNode fileNode = new FileNode(fileInfo.Remove(0, dirPath.Length));
this.BuildFileNode(fileInfo, fileNode, handleSMBAttributes, getSMBPermissions);
parent.AddFileNode(fileNode);
}
foreach (var subDirInfo in LongPathDirectoryExtension.GetDirectories(dirPath))
{
DirNode subDirNode = new DirNode(subDirInfo.Remove(0, dirPath.Length));
this.BuildDirNode(subDirInfo, subDirNode, handleSMBAttributes, getSMBPermissions);
parent.AddDirNode(subDirNode);
}
}
private void BuildFileNode(FileInfo fileInfo, FileNode fileNode, bool handleSMBAttributes, PreserveSMBPermissions getPermissions)
{
fileNode.MD5 = Helper.GetFileContentMD5(fileInfo.FullName);
fileNode.LastModifiedTime = fileInfo.LastWriteTimeUtc;
fileNode.SizeInByte = fileInfo.Length;
fileNode.Metadata = new Dictionary <string, string>();
if (CrossPlatformHelpers.IsWindows)
{
DateTimeOffset?creationTime = null;
DateTimeOffset?lastWriteTime = null;
FileAttributes?fileAttributes = null;
LongPathFileExtension.GetFileProperties(fileInfo.FullName, out creationTime, out lastWriteTime, out fileAttributes);
fileNode.CreationTime = creationTime;
fileNode.LastWriteTime = lastWriteTime;
if (handleSMBAttributes)
{
fileNode.SMBAttributes = Helper.ToCloudFileNtfsAttributes(fileAttributes.Value);
}
if (PreserveSMBPermissions.None != getPermissions)
{
fileNode.PortableSDDL = LongPathFileExtension.GetFilePortableSDDL(fileInfo.FullName, getPermissions);
}
}
}
public void GenerateDataInfo(DMLibDataInfo dataInfo, bool handleSMBAttributes, PreserveSMBPermissions getPermissions)
{
this.GenerateDir(dataInfo.RootNode, Path.Combine(this.BasePath, dataInfo.RootPath), handleSMBAttributes, getPermissions);
}
private void BuildFileNode(string path, FileNode fileNode, bool handleSMBAttributes, PreserveSMBPermissions getPermissions)
{
fileNode.MD5 = Helper.GetFileContentMD5(LongPathExtension.GetFullPath(path));
// fileNode.LastModifiedTime =
using (FileStream fs = LongPathFileExtension.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
fileNode.SizeInByte = fs.Length;
}
DateTimeOffset?creationTime = null;
DateTimeOffset?lastWriteTime = null;
FileAttributes?fileAttributes = null;
LongPathFileExtension.GetFileProperties(path, out creationTime, out lastWriteTime, out fileAttributes);
fileNode.CreationTime = creationTime;
fileNode.LastWriteTime = lastWriteTime;
if (handleSMBAttributes)
{
fileNode.SMBAttributes = Helper.ToCloudFileNtfsAttributes(fileAttributes.Value);
}
if (PreserveSMBPermissions.None != getPermissions)
{
fileNode.PortableSDDL = LongPathFileExtension.GetFilePortableSDDL(path, getPermissions);
}
fileNode.Metadata = new Dictionary <string, string>();
}
public static void SetFileSecurityInfo(string path, string portableSDDL, PreserveSMBPermissions preserveSMBPermissions)
{
FileSecurityOperations.SetFileSecurity(path, portableSDDL, preserveSMBPermissions);
}
public DMLibDataInfo GetTransferDataInfo(string rootDir, bool handleSMBAttributes, PreserveSMBPermissions getSMBPermissions)
{
#if DOTNET5_4
DirectoryInfo rootDirInfo = new DirectoryInfo(Path.Combine(this.BasePath, rootDir));
if (!rootDirInfo.Exists)
{
return(null);
}
#else
string rootDirInfo = rootDir;
if (rootDir.Length == 0)
{
rootDirInfo = LongPathExtension.Combine(this.BasePath, rootDir);
}
if (!LongPathDirectoryExtension.Exists(rootDirInfo))
{
return(null);
}
#endif
DMLibDataInfo dataInfo = new DMLibDataInfo(rootDir);
this.BuildDirNode(rootDirInfo, dataInfo.RootNode, handleSMBAttributes, getSMBPermissions);
return(dataInfo);
}
