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