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; }