protected internal static string GetFilePermissions(FileSystemInfo fileInfo) { var filename = fileInfo.FullName; FileAccessPermissions permissions = default(FileAccessPermissions); if (fileInfo is FileInfo) { try { permissions = new UnixFileInfo(filename).FileAccessPermissions; } catch (Exception ex) { Log.Debug("Unable to get access control for {0}: {1}", fileInfo.FullName, ex.Message); } } else if (fileInfo is DirectoryInfo) { try { permissions = new UnixDirectoryInfo(filename).FileAccessPermissions; } catch (Exception ex) { Log.Debug("Unable to get access control for {0}: {1}", fileInfo.FullName, ex.Message); } } else { return(null); } return(permissions.ToString()); }
public static bool CheckPathAccessModes(FileAccessPermissions permissions, AccessModes request) { if (request.HasFlag(AccessModes.R_OK)) { if (!(permissions.HasFlag(FileAccessPermissions.UserRead) || permissions.HasFlag(FileAccessPermissions.GroupRead) || permissions.HasFlag(FileAccessPermissions.OtherRead))) { return(false); } } if (request.HasFlag(AccessModes.W_OK)) { if (!(permissions.HasFlag(FileAccessPermissions.UserWrite) || permissions.HasFlag(FileAccessPermissions.GroupWrite) || permissions.HasFlag(FileAccessPermissions.OtherWrite))) { return(false); } } // ReSharper disable once InvertIf if (request.HasFlag(AccessModes.X_OK)) { if (!(permissions.HasFlag(FileAccessPermissions.UserExecute) || permissions.HasFlag(FileAccessPermissions.GroupExecute) || permissions.HasFlag(FileAccessPermissions.OtherExecute))) { return(false); } } return(true); }
public async Task CreateNewFile(string path, string localFileName, FileAccessPermissions permissions) { await CreateNewFile(path, localFileName); new UnixFileInfo(path) { FileAccessPermissions = permissions }; }
public UnixAccessInfo( UnixFileSystemInfo info, FileAccessPermissions readMask, FileAccessPermissions writeMask, FileAccessPermissions executeMask) { _info = info; _readMask = readMask; _writeMask = writeMask; _executeMask = executeMask; }
private void AssertDoesNotHavePermission(string filepath, FileAccessPermissions permission) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { return; } var info = new UnixFileInfo(filepath); Assert.False(info.FileAccessPermissions.HasFlag(permission), $"File {filepath} should not have permission {permission}"); }
/*public BFile(){ * * }*/ public FreeBSDFile(string fN, long chunkStartPos) { fileName = fN; ufi = new UnixFileInfo(fN); this.chunkStartPos = chunkStartPos; this.fileSize = ufi.Length; unixPermissions = ufi.FileAccessPermissions; fileSpecialAttributes = (int)ufi.FileSpecialAttributes; fileAttributes = 0; fileKind = GetUKind(); ownerUser = ufi.OwnerUserId; ownerGroup = ufi.OwnerGroupId; BlockMetadata = new FileBlockMetadata(); }
string formatPermissions(FileAccessPermissions p) { char ur = (p & FileAccessPermissions.UserRead) > 0 ? 'r' : '-'; char uw = (p & FileAccessPermissions.UserWrite) > 0 ? 'w' : '-'; char ux = (p & FileAccessPermissions.UserExecute) > 0 ? 'x' : '-'; char gr = (p & FileAccessPermissions.GroupRead) > 0 ? 'r' : '-'; char gw = (p & FileAccessPermissions.GroupWrite) > 0 ? 'w' : '-'; char gx = (p & FileAccessPermissions.GroupExecute) > 0 ? 'x' : '-'; char or = (p & FileAccessPermissions.OtherRead) > 0 ? 'r' : '-'; char ow = (p & FileAccessPermissions.OtherWrite) > 0 ? 'w' : '-'; char ox = (p & FileAccessPermissions.OtherExecute) > 0 ? 'x' : '-'; string result = $"{ur}{uw}{ux}{gr}{gw}{gx}{or}{ow}{ox}"; return(result); }
public static void SetLinuxFilePermission(FileAccessPermissions permissions, params string[] paths) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { return; } foreach (var path in paths) { var unixFileInfo = new UnixFileInfo(path) { FileAccessPermissions = permissions }; unixFileInfo.Refresh(); } }
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 FileAccessPermissions Permissions(string path) { /* * ufi.CanAccess (AccessModes.F_OK); // is a file/directory * ufi.CanAccess (AccessModes.R_OK); // accessible for reading * ufi.CanAccess (AccessModes.W_OK); // accessible for writing * ufi.CanAccess (AccessModes.X_OK); // accessible for executing * FileSpecialAttributes sa = ufi.FileSpecialAttributes; //setuid, setgid and sticky bits */ try { var ufi = new UnixFileInfo(path); FileAccessPermissions fa = ufi.FileAccessPermissions; return((FileAccessPermissions)fa); } catch (Exception ex) { Log.Warning(ex); return((FileAccessPermissions)0); } }
public override bool SetExecutable(string path, bool exec) { try { UnixFileInfo fi = new UnixFileInfo(path); FileAccessPermissions perms = fi.FileAccessPermissions; if (exec) { if (perms.HasFlag(FileAccessPermissions.UserRead)) { perms |= FileAccessPermissions.UserExecute; } if (perms.HasFlag(FileAccessPermissions.OtherRead)) { perms |= FileAccessPermissions.OtherExecute; } if ((perms.HasFlag(FileAccessPermissions.GroupRead))) { perms |= FileAccessPermissions.GroupExecute; } } else { if (perms.HasFlag(FileAccessPermissions.UserRead)) { perms &= ~FileAccessPermissions.UserExecute; } if (perms.HasFlag(FileAccessPermissions.OtherRead)) { perms &= ~FileAccessPermissions.OtherExecute; } if ((perms.HasFlag(FileAccessPermissions.GroupRead))) { perms &= ~FileAccessPermissions.GroupExecute; } } fi.FileAccessPermissions = perms; return(true); } catch (Exception ex) { Log.Warning(ex); return(false); } }
public override bool SetExecutable(FilePath path, bool exec) { UnixFileInfo fi = new UnixFileInfo(path); FileAccessPermissions perms = fi.FileAccessPermissions; if (exec) { if (perms.HasFlag(FileAccessPermissions.UserRead)) { perms |= FileAccessPermissions.UserExecute; } if (perms.HasFlag(FileAccessPermissions.OtherRead)) { perms |= FileAccessPermissions.OtherExecute; } if ((perms.HasFlag(FileAccessPermissions.GroupRead))) { perms |= FileAccessPermissions.GroupExecute; } } else { if (perms.HasFlag(FileAccessPermissions.UserRead)) { perms &= ~FileAccessPermissions.UserExecute; } if (perms.HasFlag(FileAccessPermissions.OtherRead)) { perms &= ~FileAccessPermissions.OtherExecute; } if ((perms.HasFlag(FileAccessPermissions.GroupRead))) { perms &= ~FileAccessPermissions.GroupExecute; } } fi.FileAccessPermissions = perms; return(true); }
// Don't change the case of this method, since ngit does reflection on it public bool setExecutable(bool exec) { try { UnixFileInfo fi = new UnixFileInfo(path); FileAccessPermissions perms = fi.FileAccessPermissions; if ((perms & FileAccessPermissions.UserRead) != 0) { perms |= FileAccessPermissions.UserExecute; } if ((perms & FileAccessPermissions.OtherRead) != 0) { perms |= FileAccessPermissions.OtherExecute; } if ((perms & FileAccessPermissions.GroupRead) != 0) { perms |= FileAccessPermissions.GroupExecute; } fi.FileAccessPermissions = perms; return(true); } catch { return(false); } }
public void Create(FileAccessPermissions mode) { Create((Native.FilePermissions)mode); }
public static bool HasFilePermission(string path, FileAccessPermissions fap) { var fi = new UnixFileInfo(path); return(HasPermission(fi, fap)); }
public void Setup(UnixFileSystemInfo u) { FullName = u.FullName; Name = u.Name; LCName = Name.ToLower (); Owner = Helpers.OwnerName(u); Group = Helpers.GroupName(u); LastModified = Helpers.LastModified(u); LastFileChange = Helpers.LastChange(FullName); Permissions = Helpers.FilePermissions(u); FileType = Helpers.FileType(u); IsDirectory = FileType == FileTypes.Directory; if (FileType == FileTypes.SymbolicLink) { LinkTarget = Helpers.ReadLink(FullName); var lt = new UnixSymbolicLinkInfo(LinkTarget); IsDirectory = Helpers.FileExists(LinkTarget) && Helpers.FileType(lt) == FileTypes.Directory; } Suffix = IsDirectory ? "" : Helpers.Extname(Name).ToLower(); Size = Helpers.FileSize(u); if (!IsDirectory) { Count = 1; SubTreeSize = Size; SubTreeCount = 1; Complete = true; FilePassDone = true; } else { Count = 0; Entries = new List<FSEntry> (); } }
public static string GetFilePermissions(FileSystemInfo fileInfo) { if (fileInfo != null) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { var filename = fileInfo.FullName; FileAccessPermissions permissions = default(FileAccessPermissions); try { if (fileInfo is FileInfo) { permissions = new UnixFileInfo(filename).FileAccessPermissions; } else if (fileInfo is DirectoryInfo) { permissions = new UnixDirectoryInfo(filename).FileAccessPermissions; } } catch (Exception e) when( e is IOException || e is InvalidOperationException ) { Log.Verbose("Unable to get access control for {0}: {1}", fileInfo.FullName, e.GetType().ToString()); } catch (Exception e) { Log.Debug($"Error Getting File Permissions {e.GetType().ToString()}"); } return(permissions.ToString()); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { var filename = fileInfo.FullName; if (filename.Length >= 260 && !filename.StartsWith(@"\\?\")) { filename = $"\\?{filename}"; } try { if (fileInfo is FileInfo) { return(new FileSecurity(filename, AccessControlSections.All).GetSecurityDescriptorSddlForm(AccessControlSections.All)); } else if (fileInfo is DirectoryInfo) { return(new DirectorySecurity(filename, AccessControlSections.All).GetSecurityDescriptorSddlForm(AccessControlSections.All)); } } catch (Exception e) when( e is ArgumentException || e is ArgumentNullException || e is DirectoryNotFoundException || e is FileNotFoundException || e is IOException || e is NotSupportedException || e is PlatformNotSupportedException || e is PathTooLongException || e is PrivilegeNotHeldException || e is SystemException || e is UnauthorizedAccessException) { var InfoType = fileInfo is FileInfo ? "FileSecurity" : "DirectorySecurity"; Log.Verbose($"Error parsing {InfoType} for {fileInfo.FullName} {e.GetType().ToString()}"); } catch (Exception e) { Log.Debug($"Error Getting File Permissions {e.GetType().ToString()}"); } return(string.Empty); } } return(string.Empty); }
public void Create (FileAccessPermissions mode) { Create ((Native.FilePermissions) mode); }
public UnixStream Create(FileAccessPermissions mode) { return Create ((Native.FilePermissions)mode); }
public Base(FileAccessPermissions permissions) { }
/// <summary> /// The chmod function sets the access permission bits for the file named by filename to mode. /// </summary> /// <returns>If filename is a symbolic link, chmod changes the permissions of the file pointed to by the link, not those of the link itself. /// This function returns 0 if successful and -1 if not. In addition to the usual file name errors (see File Name Errors), the following errno error conditions are defined for this function:</returns> public static int ChangeMode(string filename, FileAccessPermissions mode) { return(libc_chmod(filename, (int)mode)); }
public UnixStream Create(FileAccessPermissions mode) { return(Create((Native.FilePermissions)mode)); }
public static string GetFilePermissions(FileSystemInfo fileInfo) { if (fileInfo != null) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { var filename = fileInfo.FullName; FileAccessPermissions permissions = default(FileAccessPermissions); if (fileInfo is FileInfo) { try { permissions = new UnixFileInfo(filename).FileAccessPermissions; } catch (IOException ex) { Log.Debug("Unable to get access control for {0}: {1}", fileInfo.FullName, ex.Message); } } else if (fileInfo is DirectoryInfo) { try { permissions = new UnixDirectoryInfo(filename).FileAccessPermissions; } catch (IOException ex) { Log.Debug("Unable to get access control for {0}: {1}", fileInfo.FullName, ex.Message); } } else { return(null); } return(permissions.ToString()); } else { FileSystemSecurity fileSecurity = null; var filename = fileInfo.FullName; if (filename.Length >= 260 && !filename.StartsWith(@"\\?\")) { filename = $"\\?{filename}"; } if (fileInfo is FileInfo) { try { fileSecurity = new FileSecurity(filename, AccessControlSections.All); } catch (UnauthorizedAccessException) { Log.Verbose(Strings.Get("Err_AccessControl"), fileInfo.FullName); } catch (InvalidOperationException) { Log.Verbose("Invalid operation exception {0}.", fileInfo.FullName); } catch (FileNotFoundException) { Log.Verbose("File not found to get permissions {0}.", fileInfo.FullName); } catch (ArgumentException) { Log.Debug("Filename not valid for getting permissions {0}", fileInfo.FullName); } catch (Exception e) { Log.Debug(e, $"Error with {fileInfo.FullName}"); } } else if (fileInfo is DirectoryInfo) { try { fileSecurity = new DirectorySecurity(filename, AccessControlSections.All); } catch (UnauthorizedAccessException) { Log.Verbose(Strings.Get("Err_AccessControl"), fileInfo.FullName); } catch (InvalidOperationException) { Log.Verbose("Invalid operation exception {0}.", fileInfo.FullName); } catch (Exception e) { Log.Debug(e, $"Error with {fileInfo.FullName}"); } } else { return(null); } if (fileSecurity != null) { return(fileSecurity.GetSecurityDescriptorSddlForm(AccessControlSections.All)); } else { return(""); } } } return(""); }
internal static extern int Chmod(string path, FileAccessPermissions mode);
/// <summary> /// Create file then set permission (only apply for Linux platform) /// </summary> /// <param name="permissions"></param> /// <param name="paths"></param> public static void CreateIfNotExist(FileAccessPermissions permissions, params string[] paths) { CreateIfNotExist(paths); SetLinuxFilePermission(FileAccessPermissions.AllPermissions, paths); }