public void should_copy_symlink()
{
var tempFolder = GetTempFilePath();
Directory.CreateDirectory(tempFolder);
var file = Path.Combine(tempFolder, "target.txt");
var source = Path.Combine(tempFolder, "symlink_source.txt");
var destination = Path.Combine(tempFolder, "symlink_destination.txt");
File.WriteAllText(file, "Some content");
new UnixSymbolicLinkInfo(source).CreateSymbolicLinkTo(file);
Subject.CopyFile(source, destination);
File.Exists(file).Should().BeTrue();
File.Exists(source).Should().BeTrue();
File.Exists(destination).Should().BeTrue();
UnixFileSystemInfo.GetFileSystemEntry(source).IsSymbolicLink.Should().BeTrue();
UnixFileSystemInfo.GetFileSystemEntry(destination).IsSymbolicLink.Should().BeTrue();
File.ReadAllText(source).Should().Be("Some content");
File.ReadAllText(destination).Should().Be("Some content");
}
public override bool TryCreateHardLink(string source, string destination)
{
try
{
var fileInfo = UnixFileSystemInfo.GetFileSystemEntry(source);
if (fileInfo.IsSymbolicLink)
{
return(false);
}
fileInfo.CreateLink(destination);
return(true);
}
catch (UnixIOException ex)
{
if (ex.ErrorCode == Errno.EXDEV)
{
_logger.Trace("Hardlink '{0}' to '{1}' failed due to cross-device access.", source, destination);
}
else
{
_logger.Debug(ex, "Hardlink '{0}' to '{1}' failed.", source, destination);
}
return(false);
}
catch (Exception ex)
{
_logger.Debug(ex, "Hardlink '{0}' to '{1}' failed.", source, destination);
return(false);
}
}
private UnixFileSystemInfo TraverseSymlink(UnixFileSystemInfo info)
{
lock (visited_symlinks) {
visited_symlinks.Clear();
while (info.IsSymbolicLink)
{
if (visited_symlinks.Contains(info.FullName))
{
return(null);
}
visited_symlinks.Add(info.FullName);
var target = new UnixSymbolicLinkInfo(info.FullName).GetContents();
if (info.FullName.StartsWith(target.FullName))
{
return(null);
}
if (!target.Exists)
{
return(null);
}
info = target;
}
return(info);
}
}
public void Generate(ShortcutRequest shortcutRequest)
{
var shortcutName = shortcutRequest.ShortcutName.ToLower().Replace(" ", "-");
var shortcutPath = Path.Combine(
shortcutRequest.ShortcutDirectoryPath,
$"{shortcutName}.desktop");
if (File.Exists(shortcutPath))
{
var exception = new InvalidOperationException("Shortcut already exists.");
exception.Data[ExceptionData.ShortcutPath] = shortcutPath;
throw exception;
}
var shortcutBuilder = new StringBuilder();
shortcutBuilder.AppendLine("[Desktop Entry]");
shortcutBuilder.AppendLine($"Name={shortcutRequest.ShortcutName}");
shortcutBuilder.AppendLine($"Exec={shortcutRequest.SourceFullPath}");
shortcutBuilder.AppendLine($"Path={shortcutRequest.WorkingDirectory}");
shortcutBuilder.AppendLine("Type=Application");
shortcutBuilder.AppendLine($"Icon={shortcutRequest.IconPath}");
shortcutBuilder.AppendLine("Comment=");
shortcutBuilder.AppendLine("Terminal=false");
File.WriteAllText(shortcutPath, shortcutBuilder.ToString());
UnixFileSystemInfo.GetFileSystemEntry(shortcutPath).FileAccessPermissions |= FileAccessPermissions.UserExecute;
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseSystemd()
.ConfigureAppConfiguration((hostContext, config) =>
{
// see chmod(2), https://linux.die.net/man/2/chmod for reference
FilePermissions root600 =
FilePermissions.S_IRUSR | FilePermissions.S_IWUSR | FilePermissions.S_IFREG;
FilePermissions root640 =
FilePermissions.S_IRUSR | FilePermissions.S_IWUSR | FilePermissions.S_IRGRP | FilePermissions.S_IFREG;
if (File.Exists("/etc/EchoSeven/appsettings.json") &&
UnixFileSystemInfo.GetFileSystemEntry("/etc/EchoSeven/appsettings.json").OwnerUser.UserName.Equals("root") &&
UnixFileSystemInfo.GetFileSystemEntry("/etc/EchoSeven/appsettings.json").OwnerGroup.GroupName.Equals("root") &&
(UnixFileSystemInfo.GetFileSystemEntry("/etc/EchoSeven/appsettings.json").Protection.Equals(root600) ||
UnixFileSystemInfo.GetFileSystemEntry("/etc/EchoSeven/appsettings.json").Protection.Equals(root640)) &&
UnixEnvironment.EffectiveUser.UserName.Equals("root"))
{
var settings = config.Build();
config.AddJsonFile("/etc/EchoSeven/appsettings.json", optional: true, reloadOnChange: false);
}
})
.ConfigureServices((hostContext, services) =>
{
IConfiguration configuration = hostContext.Configuration;
EchoServerOptions options = configuration.GetSection("EchoService").Get <EchoServerOptions>();
services.AddSingleton(options);
services.AddHostedService <EchoSevenService>();
});
private static bool SymlinkedDirExists(string dirPath)
{
dirPath = dirPath.TrimEnd(Path.DirectorySeparatorChar);
try
{
UnixFileSystemInfo fileSystemInfo = UnixFileSystemInfo.GetFileSystemEntry(dirPath);
if (!fileSystemInfo.IsSymbolicLink)
{
return(false);
}
UnixSymbolicLinkInfo symlinkInfo = fileSystemInfo as UnixSymbolicLinkInfo;
if (symlinkInfo.HasContents && symlinkInfo.GetContents().IsDirectory)
{
return(true);
}
}
catch (DllNotFoundException ex)
{
throw new TransferException(TransferErrorCode.FailToEnumerateDirectory,
Resources.UnableToLoadDLL,
ex);
}
return(false);
}
protected override void CopyFileInternal(string source, string destination, bool overwrite)
{
var sourceInfo = UnixFileSystemInfo.GetFileSystemEntry(source);
if (sourceInfo.IsSymbolicLink)
{
var isSameDir = UnixPath.GetDirectoryName(source) == UnixPath.GetDirectoryName(destination);
var symlinkInfo = (UnixSymbolicLinkInfo)sourceInfo;
var symlinkPath = symlinkInfo.ContentsPath;
var newFile = new UnixSymbolicLinkInfo(destination);
if (FileExists(destination) && overwrite)
{
DeleteFile(destination);
}
if (isSameDir)
{
// We're in the same dir, so we can preserve relative symlinks.
newFile.CreateSymbolicLinkTo(symlinkInfo.ContentsPath);
}
else
{
var fullPath = UnixPath.Combine(UnixPath.GetDirectoryName(source), symlinkPath);
newFile.CreateSymbolicLinkTo(fullPath);
}
}
else
{
base.CopyFileInternal(source, destination, overwrite);
}
}
static Func <Process> GetSpawner(ConfigurationManager configurationManager, string filename, ChildConfigurationManager childConfigurationManager, string configFile)
{
Func <Process> spawner;
if (childConfigurationManager.InstanceType == InstanceType.Ondemand)
{
if (String.IsNullOrEmpty(childConfigurationManager.ShimSocket))
{
throw new Exception("You must specify a socket for the shim");
}
spawner = () => Spawner.SpawnOndemandChild(childConfigurationManager.ShimSocket);
}
else
{
spawner = () => Spawner.SpawnStaticChild(configFile, configurationManager.FastCgiCommand);
}
Action spawnShim = () => Spawner.SpawnShim(configurationManager, childConfigurationManager.ShimSocket, configFile);
string user = childConfigurationManager.User;
string group = childConfigurationManager.Group;
if (String.IsNullOrEmpty(user))
{
if (Platform.IsUnix)
{
Logger.Write(LogLevel.Warning, "Configuration file {0} didn't specify username, defaulting to file owner", filename);
string owner = UnixFileSystemInfo.GetFileSystemEntry(configFile).OwnerUser.UserName;
if (childConfigurationManager.InstanceType == InstanceType.Ondemand)
{
Spawner.RunAs(owner, group, spawnShim) ();
}
else
{
spawner = Spawner.RunAs(owner, group, spawner);
}
}
else
{
Logger.Write(LogLevel.Warning, "Configuration file {0} didn't specify username, defaulting to the current one", filename);
if (childConfigurationManager.InstanceType != InstanceType.Ondemand)
{
spawnShim();
}
}
}
else
{
if (childConfigurationManager.InstanceType == InstanceType.Ondemand)
{
Spawner.RunAs(user, group, spawnShim) ();
}
else
{
spawner = Spawner.RunAs(user, group, spawner);
}
}
return(spawner);
}
protected UnixFileSystemEntry(
UnixFileSystemInfo info)
{
GenericInfo = _info = info;
Permissions = new UnixPermissions(info);
Owner = GetNameOrId(() => info.OwnerUser.UserName, () => info.OwnerUserId);
Group = GetNameOrId(() => info.OwnerGroup.GroupName, () => info.OwnerGroupId);
}
public void CleanupDownloads()
{
Directory.Delete(_downloadDir, true);
Directory.CreateDirectory(_downloadDir);
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
UnixFileSystemInfo.GetFileSystemEntry(_downloadDir).FileAccessPermissions = FileAccessPermissions.AllPermissions;
}
}
public virtual void SetFileAttributes(string fileName, object attributes)
{
if (attributes == null)
{
return;
}
UnixFileSystemInfo info = UnixFileSystemInfo.GetFileSystemEntry(fileName);
info.FileAccessPermissions = (FileAccessPermissions)attributes;
}
// Used for preserve the file attributes when monodevelop opens & writes a file.
// This should work on unix & mac platform.
public virtual object GetFileAttributes(string fileName)
{
UnixFileSystemInfo info = UnixFileSystemInfo.GetFileSystemEntry(fileName);
if (info == null)
{
return(null);
}
return(info.FileAccessPermissions);
}
public async Task ShouldDownloadAndExtractFirefoxLinuxBinary()
{
using var browserFetcher = Puppeteer.CreateBrowserFetcher(new BrowserFetcherOptions
{
Platform = Platform.Linux,
Path = _downloadsFolder,
Host = TestConstants.ServerUrl,
Product = Product.Firefox
});
var expectedVersion = "75.0a1";
var revisionInfo = browserFetcher.RevisionInfo(expectedVersion);
Server.SetRedirect(
revisionInfo.Url.Substring(TestConstants.ServerUrl.Length),
"/firefox.zip");
Assert.False(revisionInfo.Local);
Assert.Equal(Platform.Linux, revisionInfo.Platform);
Assert.False(await browserFetcher.CanDownloadAsync("100000"));
Assert.True(await browserFetcher.CanDownloadAsync(expectedVersion));
try
{
revisionInfo = await browserFetcher.DownloadAsync(expectedVersion);
Assert.True(revisionInfo.Local);
Assert.Equal("FIREFOX LINUX BINARY\n", File.ReadAllText(revisionInfo.ExecutablePath));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
#if NETCOREAPP //This will not be run on net4x anyway.
Mono.Unix.FileAccessPermissions permissions = ConvertPermissions(LinuxSysCall.ExecutableFilePermissions);
Assert.Equal(permissions, UnixFileSystemInfo.GetFileSystemEntry(revisionInfo.ExecutablePath).FileAccessPermissions & permissions);
#endif
}
Assert.Equal(new[] { expectedVersion }, browserFetcher.LocalRevisions());
browserFetcher.Remove(expectedVersion);
Assert.Empty(browserFetcher.LocalRevisions());
//Download should return data from a downloaded version
//This section is not in the Puppeteer test.
await browserFetcher.DownloadAsync(expectedVersion);
Server.Reset();
revisionInfo = await browserFetcher.DownloadAsync(expectedVersion);
Assert.True(revisionInfo.Local);
Assert.Equal("FIREFOX LINUX BINARY\n", File.ReadAllText(revisionInfo.ExecutablePath));
}
finally
{
EnsureDownloadsFolderIsDeleted();
}
}
public UnixAccessInfo(
UnixFileSystemInfo info,
FileAccessPermissions readMask,
FileAccessPermissions writeMask,
FileAccessPermissions executeMask)
{
_info = info;
_readMask = readMask;
_writeMask = writeMask;
_executeMask = executeMask;
}
internal static void UnixSetFileAccessExecutable(string path)
{
if (!File.Exists(path) || !UnixFileSystemInfo.TryGetFileSystemEntry(path, out UnixFileSystemInfo entry))
{
return;
}
if (!entry.FileAccessPermissions.HasFlag(FileAccessPermissions.UserExecute))
{
entry.FileAccessPermissions = entry.FileAccessPermissions | FileAccessPermissions.UserExecute;
}
}
protected override void CloneFileInternal(string source, string destination, bool overwrite)
{
if (!File.Exists(destination) && !UnixFileSystemInfo.GetFileSystemEntry(source).IsSymbolicLink)
{
if (_createRefLink.TryCreateRefLink(source, destination))
{
return;
}
}
CopyFileInternal(source, destination, overwrite);
}
public void UpdatePermissionsOnUnixUsingMonoPosix()
{
var fileSystemEntry = UnixFileSystemInfo.GetFileSystemEntry("path");
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.UserRead;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.UserWrite;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.UserExecute;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.UserReadWriteExecute;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.GroupRead;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.GroupWrite;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.GroupExecute;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.GroupReadWriteExecute;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.UserRead | FileAccessPermissions.GroupRead;
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.AllPermissions; // Noncompliant (DefaultPermissions | OtherExecute | GroupExecute | UserExecute, // 0x000001FF)
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.DefaultPermissions; // Noncompliant (OtherWrite | OtherRead | GroupWrite | GroupRead | UserWrite | UserRead, // 0x000001B6)
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.OtherReadWriteExecute; // Noncompliant
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.OtherExecute; // Noncompliant
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.OtherWrite; // Noncompliant
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.OtherRead; // Noncompliant {{Make sure this permission is safe.}}
fileSystemEntry.FileAccessPermissions |= FileAccessPermissions.AllPermissions; // Noncompliant (DefaultPermissions | OtherExecute | GroupExecute | UserExecute, // 0x000001FF)
fileSystemEntry.FileAccessPermissions |= FileAccessPermissions.DefaultPermissions; // Noncompliant (OtherWrite | OtherRead | GroupWrite | GroupRead | UserWrite | UserRead, // 0x000001B6)
fileSystemEntry.FileAccessPermissions |= FileAccessPermissions.OtherReadWriteExecute; // Noncompliant
fileSystemEntry.FileAccessPermissions |= FileAccessPermissions.OtherExecute; // Noncompliant
fileSystemEntry.FileAccessPermissions |= FileAccessPermissions.OtherWrite; // Noncompliant
fileSystemEntry.FileAccessPermissions |= FileAccessPermissions.OtherRead; // Noncompliant
fileSystemEntry.FileAccessPermissions ^= FileAccessPermissions.AllPermissions; // Noncompliant - depending on the case this might add or remove permissions
fileSystemEntry.FileAccessPermissions ^= FileAccessPermissions.DefaultPermissions; // Noncompliant
fileSystemEntry.FileAccessPermissions ^= FileAccessPermissions.OtherReadWriteExecute; // Noncompliant
fileSystemEntry.FileAccessPermissions ^= FileAccessPermissions.OtherExecute; // Noncompliant
fileSystemEntry.FileAccessPermissions ^= FileAccessPermissions.OtherWrite; // Noncompliant
fileSystemEntry.FileAccessPermissions ^= FileAccessPermissions.OtherRead; // Noncompliant
fileSystemEntry.FileAccessPermissions = FileAccessPermissions.UserRead | FileAccessPermissions.GroupRead | FileAccessPermissions.OtherRead; // Noncompliant
// ^^^^^^^^^
UnixFileInfo.GetFileSystemEntry("path").FileAccessPermissions = FileAccessPermissions.AllPermissions; // Noncompliant
UnixSymbolicLinkInfo.GetFileSystemEntry("path").FileAccessPermissions = FileAccessPermissions.AllPermissions; // Noncompliant
if (fileSystemEntry.FileAccessPermissions != FileAccessPermissions.OtherExecute)
{
}
while (fileSystemEntry.FileAccessPermissions != FileAccessPermissions.OtherExecute)
{
}
_ = fileSystemEntry.FileAccessPermissions == FileAccessPermissions.OtherWrite ? 1 : 2;
fileSystemEntry.FileAccessPermissions = ~((FileAccessPermissions.OtherRead));
fileSystemEntry.FileAccessPermissions = ~FileAccessPermissions.OtherRead;
}
public override bool TryCreateHardLink(string source, string destination)
{
try
{
UnixFileSystemInfo.GetFileSystemEntry(source).CreateLink(destination);
return(true);
}
catch (Exception ex)
{
Logger.Debug(ex, string.Format("Hardlink '{0}' to '{1}' failed.", source, destination));
return(false);
}
}
private IUnixFileSystemEntry CreateEntry(IUnixDirectoryEntry parent, UnixFileSystemInfo info)
{
switch (info)
{
case UnixFileInfo fileInfo:
return(new UnixFileEntry(fileInfo));
case UnixDirectoryInfo dirInfo:
return(new UnixDirectoryEntry(dirInfo, _user, _userInfo, parent));
default:
throw new NotSupportedException($"Unsupported file system info type {info}");
}
}
public async Task ShouldDownloadAndExtractLinuxBinary()
{
var browserFetcher = Puppeteer.CreateBrowserFetcher(new BrowserFetcherOptions
{
Platform = Platform.Linux,
Path = _downloadsFolder,
Host = TestConstants.ServerUrl
});
var revisionInfo = browserFetcher.RevisionInfo(123456);
Server.SetRedirect(revisionInfo.Url.Substring(TestConstants.ServerUrl.Length), "/chromium-linux.zip");
Assert.False(revisionInfo.Local);
Assert.Equal(Platform.Linux, revisionInfo.Platform);
Assert.False(await browserFetcher.CanDownloadAsync(100000));
Assert.True(await browserFetcher.CanDownloadAsync(123456));
try
{
revisionInfo = await browserFetcher.DownloadAsync(123456);
Assert.True(revisionInfo.Local);
Assert.Equal("LINUX BINARY\n", File.ReadAllText(revisionInfo.ExecutablePath));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
#if NETCOREAPP //don't need to run this code if we're not netcore app since net471 won't run on NIX. And UnixFileSystemInfo is not available for net471
Assert.Equal(
LinuxPermissionsSetter.ExecutableFilePermissions,
UnixFileSystemInfo.GetFileSystemEntry(revisionInfo.ExecutablePath).FileAccessPermissions & LinuxPermissionsSetter.ExecutableFilePermissions);
#endif
}
Assert.Equal(new[] { 123456 }, browserFetcher.LocalRevisions());
browserFetcher.Remove(123456);
Assert.Empty(browserFetcher.LocalRevisions());
//Download should return data from a downloaded version
//This section is not in the Puppeteer test.
await browserFetcher.DownloadAsync(123456);
Server.Reset();
revisionInfo = await browserFetcher.DownloadAsync(123456);
Assert.True(revisionInfo.Local);
Assert.Equal("LINUX BINARY\n", File.ReadAllText(revisionInfo.ExecutablePath));
}
finally
{
EnsureDownloadsFolderIsDeleted();
}
}
private static void SetUnixPermissionGroup(FilePermissions value,
char[] access, int index,
FilePermissions read, FilePermissions write, FilePermissions exec,
char both, char setonly, FilePermissions setxbit)
{
if (UnixFileSystemInfo.IsSet(value, read))
{
access [index] = 'r';
}
if (UnixFileSystemInfo.IsSet(value, write))
{
access [index + 1] = 'w';
}
access [index + 2] = GetSymbolicMode(value, exec, both, setonly, setxbit);
}
static UnixFileSystemInfo GetUnixFileInfo(string path)
{
try {
return(UnixFileSystemInfo.GetFileSystemEntry(path));
} catch (DirectoryNotFoundException ex) {
// If we have a file /foo/bar and probe the path /foo/bar/baz, we get a DirectoryNotFound exception
// because 'bar' is a file and therefore 'baz' cannot possibly exist. This is annoying.
var inner = ex.InnerException as UnixIOException;
if (inner != null && inner.ErrorCode == Mono.Unix.Native.Errno.ENOTDIR)
{
return(null);
}
throw;
}
}
private static EnumerateFileEntryInfo GetFileEntryInfo(string filePath)
{
EnumerateFileEntryInfo fileEntryInfo = new EnumerateFileEntryInfo()
{
FileName = LongPath.GetFileName(filePath),
FileAttributes = FileAttributes.Normal,
SymlinkTarget = null
};
#if DOTNET5_4
try
{
UnixFileSystemInfo fileSystemInfo = UnixFileSystemInfo.GetFileSystemEntry(filePath);
if (fileSystemInfo.IsSymbolicLink)
{
fileEntryInfo.FileAttributes |= FileAttributes.ReparsePoint;
fileEntryInfo.SymlinkTarget = Path.GetFullPath(Path.Combine(GetParentPath(filePath), (fileSystemInfo as UnixSymbolicLinkInfo).ContentsPath));
UnixSymbolicLinkInfo symlinkInfo = fileSystemInfo as UnixSymbolicLinkInfo;
try
{
if (symlinkInfo.HasContents && symlinkInfo.GetContents().IsDirectory)
{
fileEntryInfo.FileAttributes |= FileAttributes.Directory;
}
}
catch (InvalidOperationException)
{
// Just ignore exception thrown here.
// later there will be "FileNotFoundException" thrown out when trying to open the file before transferring.
}
}
if (fileSystemInfo.IsDirectory)
{
fileEntryInfo.FileAttributes |= FileAttributes.Directory;
}
}
catch (DllNotFoundException ex)
{
throw new TransferException(TransferErrorCode.FailToEnumerateDirectory,
Resources.UnableToLoadDLL,
ex);
}
#endif
return(fileEntryInfo);
}
/// <summary>
/// GTK-specific implementation.
/// </summary>
static partial void UpdateAvailablePorts()
{
// We'll just see how this holds up... It may only work for USB-serial devices, and not hard-wired serial ports.
// If the need for detecting those arises, may need to call out to ioctl functions to do it.
_devTtyPathToDeviceId.Clear();
if (Directory.Exists("/dev/serial/"))
{
var serialDevices = Directory.EnumerateFiles("/dev/serial/by-id/");
foreach (var serialDevice in serialDevices)
{
var linkInfo = UnixFileSystemInfo.GetFileSystemEntry(serialDevice) as UnixSymbolicLinkInfo;
_devTtyPathToDeviceId[linkInfo.GetContents().FullName] = serialDevice;
}
}
_availablePorts = _devTtyPathToDeviceId.Keys.ToArray();
}
public virtual int ReadFrom(byte[] buffer, int offset)
{
RecordType = (CatalogRecordType)Utilities.ToInt16BigEndian(buffer, offset + 0);
FileId = Utilities.ToUInt32BigEndian(buffer, offset + 8);
CreateTime = HfsPlusUtilities.ReadHFSPlusDate(DateTimeKind.Utc, buffer, offset + 12);
ContentModifyTime = HfsPlusUtilities.ReadHFSPlusDate(DateTimeKind.Utc, buffer, offset + 16);
AttributeModifyTime = HfsPlusUtilities.ReadHFSPlusDate(DateTimeKind.Utc, buffer, offset + 20);
AccessTime = HfsPlusUtilities.ReadHFSPlusDate(DateTimeKind.Utc, buffer, offset + 24);
BackupTime = HfsPlusUtilities.ReadHFSPlusDate(DateTimeKind.Utc, buffer, offset + 28);
uint special;
FileSystemInfo = HfsPlusUtilities.ReadBsdInfo(buffer, offset + 32, out special);
UnixSpecialField = special;
return 0;
}
public void StartUnixSocket(string socketPath)
{
if (socketPath == null)
{
throw new ArgumentNullException("socketPath");
}
try {
socketPath = Path.GetFullPath(socketPath);
if (File.Exists(socketPath))
{
var info = UnixFileSystemInfo.GetFileSystemEntry(socketPath);
if (info.IsSocket)
{
// if the file is a socket, it probably came from us, so overwrite it.
File.Delete(socketPath);
}
else
{
// don't want to overwrite anything that is not a socket file though.
var message = string.Format("The file '{0}' already exists.", socketPath);
throw new Exception(message);
}
}
// set file permission to user only.
var prevUmask = Syscall.umask(
FilePermissions.S_IXUSR |
FilePermissions.S_IRWXG |
FilePermissions.S_IRWXO);
// file is created in UnixListener()
try {
listener = new UnixListener(socketPath);
} finally {
Syscall.umask(prevUmask);
}
listener.Start();
connectionThread = new Thread(AcceptConnections)
{
Name = "UnixAgent"
};
connectionThread.Start();
} catch (Exception ex) {
var message = string.Format("Failed to start Unix Agent: {0}", ex.Message);
throw new Exception(message, ex);
}
}
protected override void MoveFileInternal(string source, string destination)
{
var sourceInfo = UnixFileSystemInfo.GetFileSystemEntry(source);
if (sourceInfo.IsSymbolicLink)
{
var isSameDir = UnixPath.GetDirectoryName(source) == UnixPath.GetDirectoryName(destination);
var symlinkInfo = (UnixSymbolicLinkInfo)sourceInfo;
var symlinkPath = symlinkInfo.ContentsPath;
var newFile = new UnixSymbolicLinkInfo(destination);
if (isSameDir)
{
// We're in the same dir, so we can preserve relative symlinks.
newFile.CreateSymbolicLinkTo(symlinkInfo.ContentsPath);
}
else
{
var fullPath = UnixPath.Combine(UnixPath.GetDirectoryName(source), symlinkPath);
newFile.CreateSymbolicLinkTo(fullPath);
}
try
{
// Finally remove the original symlink.
symlinkInfo.Delete();
}
catch
{
// Removing symlink failed, so rollback the new link and throw.
newFile.Delete();
throw;
}
}
else if ((PlatformInfo.Platform == PlatformType.Mono && PlatformInfo.GetVersion() >= new Version(6, 0)) ||
PlatformInfo.Platform == PlatformType.NetCore)
{
TransferFilePatched(source, destination, false, true);
}
else
{
base.MoveFileInternal(source, destination);
}
}
public UnixPermissions(UnixFileSystemInfo info)
{
User = new UnixAccessInfo(
info,
FileAccessPermissions.UserRead,
FileAccessPermissions.UserWrite,
FileAccessPermissions.UserExecute);
Group = new UnixAccessInfo(
info,
FileAccessPermissions.GroupRead,
FileAccessPermissions.GroupWrite,
FileAccessPermissions.GroupExecute);
Other = new UnixAccessInfo(
info,
FileAccessPermissions.OtherRead,
FileAccessPermissions.OtherWrite,
FileAccessPermissions.OtherExecute);
}
public static bool HasPermission(UnixFileSystemInfo fi, FileAccessPermissions fap)
{
var effective = fi.FileAccessPermissions & fap;
var user = UnixUserInfo.GetRealUser();
if (user.UserId == fi.OwnerUserId)
{
return((effective & FileAccessPermissions.UserReadWriteExecute) == (fap & FileAccessPermissions.UserReadWriteExecute));
}
else if (user.GroupId == fi.OwnerGroupId)
{
return((effective & FileAccessPermissions.GroupReadWriteExecute) == (fap & FileAccessPermissions.GroupReadWriteExecute));
}
else
{
return((effective & FileAccessPermissions.OtherReadWriteExecute) == (fap & FileAccessPermissions.OtherReadWriteExecute));
}
}
public UnixFileSystemInfo GetUnixFileInfo(string path)
{
File file = GetFile(path);
Inode inode = file.Inode;
DeviceInode devInod = inode as DeviceInode;
UnixFileSystemInfo info = new UnixFileSystemInfo
{
FileType = FileTypeFromInodeType(inode.Type),
UserId = GetId(inode.UidKey),
GroupId = GetId(inode.GidKey),
Permissions = (UnixFilePermissions)inode.Mode,
Inode = inode.InodeNumber,
LinkCount = inode.NumLinks,
DeviceId = devInod == null ? 0 : devInod.DeviceId
};
return(info);
}
public static UnixFileSystemInfo ReadBsdInfo(byte[] buffer, int offset, out uint special)
{
UnixFileSystemInfo result = new UnixFileSystemInfo();
result.UserId = Utilities.ToInt32BigEndian(buffer, offset + 0);
result.GroupId = Utilities.ToInt32BigEndian(buffer, offset + 4);
ushort fileMode = Utilities.ToUInt16BigEndian(buffer, offset + 8);
result.FileType = (UnixFileType)((fileMode >> 12) & 0xF);
result.Permissions = (UnixFilePermissions)(fileMode & 0xFFF);
special = Utilities.ToUInt32BigEndian(buffer, offset + 10);
if (result.FileType == UnixFileType.Block || result.FileType == UnixFileType.Character)
{
result.DeviceId = special;
}
return result;
}
