/// <summary>
/// Initializes a new instance of the <see cref="FactsListFormatter"/> class.
/// </summary>
/// <param name="user">The user to create this formatter for</param>
/// <param name="fileSystem">The file system where the file system entries are from</param>
/// <param name="pathEntries">The current path</param>
/// <param name="activeFacts">The active facts to return for the entries</param>
public FactsListFormatter(FtpUser user, IUnixFileSystem fileSystem, Stack<IUnixDirectoryEntry> pathEntries, ISet<string> activeFacts)
{
_user = user;
_fileSystem = fileSystem;
_pathEntries = pathEntries;
_activeFacts = activeFacts;
}
public PermissionsFact(IFtpUser user, IUnixFileSystem fileSystem, IUnixDirectoryEntry dir, IUnixFileEntry entry)
{
var values = new StringBuilder();
var entryPerm = entry.Permissions.GetAccessModeFor(entry, user);
var dirPerm = dir.Permissions.GetAccessModeFor(dir, user);
if (dirPerm.Write)
{
values.Append('c');
if (entryPerm.Write)
{
if (fileSystem.SupportsAppend)
{
values.Append('a');
}
values.Append('d');
values.Append('f');
}
}
if (entryPerm.Read)
{
values.Append('r');
}
if (entryPerm.Write)
{
values.Append('w');
}
Value = values.ToString();
}
/// <summary>
/// Tries to select the given <paramref name="path"/>.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="path">The path to select.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The result of the selection.</returns>
public static Task <PathSelectionResult> SelectAsync(
this IUnixFileSystem fileSystem,
string?path,
CancellationToken cancellationToken)
{
return(SelectAsync(fileSystem, Enumerable.Empty <IUnixDirectoryEntry>(), path, cancellationToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryDirectoryEntry"/> class.
/// </summary>
/// <param name="fileSystem">The file system this entry belongs to.</param>
/// <param name="parent">The parent entry.</param>
/// <param name="name">The name of this entry.</param>
/// <param name="children">The children of this directory entry.</param>
public InMemoryDirectoryEntry(
IUnixFileSystem fileSystem,
InMemoryDirectoryEntry parent,
string name,
IDictionary <string, IUnixFileSystemEntry> children)
: base(fileSystem, parent, name, _defaultPermissions)
{
Children = children;
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryFileEntry"/> class.
/// </summary>
/// <param name="fileSystem">The file system this entry belongs to.</param>
/// <param name="parent">The parent entry.</param>
/// <param name="name">The name of this entry.</param>
/// <param name="data">The file data.</param>
public InMemoryFileEntry(
IUnixFileSystem fileSystem,
InMemoryDirectoryEntry parent,
string name,
byte[] data)
: base(fileSystem, parent, name, _defaultPermissions)
{
Data = data;
}
/// <summary>
/// Initializes a new instance of the <see cref="GoogleDriveDirectoryEntry"/> class.
/// </summary>
/// <param name="fileSystem">The file system this instance belongs to.</param>
/// <param name="file">The directory this entry belongs to.</param>
/// <param name="fullPath">The full path.</param>
/// <param name="isRoot">Determines whether this a root directory.</param>
public GoogleDriveDirectoryEntry([NotNull] IUnixFileSystem fileSystem, [NotNull] File file, [NotNull] string fullPath, bool isRoot = false)
{
FileSystem = fileSystem;
File = file;
Permissions = new GenericUnixPermissions(
new GenericAccessMode(true, true, true),
new GenericAccessMode(true, true, true),
new GenericAccessMode(true, true, true));
FullName = fullPath;
IsRoot = isRoot;
Name = File.Name;
NumberOfLinks = File.Parents?.Count ?? 1;
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryFileSystemEntry"/> class.
/// </summary>
/// <param name="fileSystem">The file system this entry belongs to.</param>
/// <param name="parent">The parent entry.</param>
/// <param name="name">The name of this entry.</param>
/// <param name="permissions">The permissions of this entry.</param>
protected InMemoryFileSystemEntry(
IUnixFileSystem fileSystem,
InMemoryDirectoryEntry parent,
string name,
IUnixPermissions permissions)
{
FileSystem = fileSystem;
Name = name;
Permissions = permissions;
Parent = parent;
Owner = "owner";
Group = "group";
CreatedTime = DateTimeOffset.Now;
}
public MlstFtpResponse(
ISet <string> activeMlstFacts,
ClaimsPrincipal user,
IUnixFileSystem fileSystem,
IUnixFileSystemEntry targetEntry,
Stack <IUnixDirectoryEntry> path)
: base(250, $" {targetEntry.Name}", "End")
{
_activeMlstFacts = activeMlstFacts;
_user = user;
_fileSystem = fileSystem;
_targetEntry = targetEntry;
_path = path;
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectoryListingEnumerator"/> class.
/// </summary>
/// <param name="entries">The file system entries to enumerate.</param>
/// <param name="fileSystem">The file system of the file system entries.</param>
/// <param name="pathEntries">The path entries of the current directory.</param>
/// <param name="returnDotEntries"><code>true</code> when this enumerator should return the dot entries.</param>
public DirectoryListingEnumerator(IEnumerable <IUnixFileSystemEntry> entries, IUnixFileSystem fileSystem, Stack <IUnixDirectoryEntry> pathEntries, bool returnDotEntries)
{
FileSystem = fileSystem;
_pathEntries = pathEntries;
var topPathEntries = pathEntries.Take(3).ToList();
switch (topPathEntries.Count)
{
case 0:
CurrentDirectory = fileSystem.Root;
ParentDirectory = null;
GrandParentDirectory = null;
break;
case 1:
CurrentDirectory = topPathEntries[0];
ParentDirectory = fileSystem.Root;
GrandParentDirectory = null;
break;
case 2:
CurrentDirectory = topPathEntries[0];
ParentDirectory = topPathEntries[1];
GrandParentDirectory = fileSystem.Root;
break;
default:
CurrentDirectory = topPathEntries[0];
ParentDirectory = topPathEntries[1];
GrandParentDirectory = topPathEntries[2];
break;
}
var dotEntries = new List <Tuple <IUnixDirectoryEntry, string> >();
if (returnDotEntries)
{
dotEntries.Add(Tuple.Create(CurrentDirectory, "."));
if (ParentDirectory != null)
{
dotEntries.Add(Tuple.Create(ParentDirectory, ".."));
}
}
_dotEntriesEnumerator = dotEntries.GetEnumerator();
_entriesEnumerator = entries.GetEnumerator();
}
/// <summary>
/// Initializes a new instance of the <see cref="GoogleDriveFileEntry"/> class.
/// </summary>
/// <param name="fileSystem">The file system this entry belongs to.</param>
/// <param name="file">The underlying model.</param>
/// <param name="fullName">The full path and file name of this entry.</param>
/// <param name="fileSize">The file size (if it differs from the one in the model).</param>
public GoogleDriveFileEntry(
[NotNull] IUnixFileSystem fileSystem,
[NotNull] File file,
[NotNull] string fullName,
long?fileSize = null)
{
FileSystem = fileSystem;
File = file;
Permissions = new GenericUnixPermissions(
new GenericAccessMode(true, true, false),
new GenericAccessMode(true, true, false),
new GenericAccessMode(true, true, false));
FullName = fullName;
Size = fileSize ?? file.Size ?? 0;
NumberOfLinks = File.Parents?.Count ?? 1;
}
public static async Task <SearchResult <IUnixFileEntry> > SearchFileAsync(this IUnixFileSystem fileSystem, [NotNull, ItemNotNull] Stack <IUnixDirectoryEntry> currentPath, [NotNull, ItemNotNull] IReadOnlyList <string> pathElements, CancellationToken cancellationToken)
{
var sourceDir = await GetDirectoryAsync(fileSystem, currentPath, new ListSegment <string>(pathElements, 0, pathElements.Count - 1), cancellationToken);
if (sourceDir == null)
{
return(null);
}
var fileName = pathElements[pathElements.Count - 1];
var foundEntry = await fileSystem.GetEntryByNameAsync(sourceDir, fileName, cancellationToken);
var foundFileEntry = foundEntry as IUnixFileEntry;
if (foundEntry != null && foundFileEntry == null)
{
return(null);
}
return(new SearchResult <IUnixFileEntry>(sourceDir, foundFileEntry, fileName));
}
public static async Task <IUnixDirectoryEntry> GetDirectoryAsync([NotNull] this IUnixFileSystem fileSystem, [NotNull, ItemNotNull] Stack <IUnixDirectoryEntry> currentPath, [NotNull, ItemNotNull] IReadOnlyList <string> pathElements, CancellationToken cancellationToken)
{
IUnixDirectoryEntry currentDir = currentPath.Count == 0 ? fileSystem.Root : currentPath.Peek();
foreach (var pathElement in pathElements)
{
if (pathElement == string.Empty)
{
currentDir = fileSystem.Root;
currentPath.Clear();
continue;
}
if (pathElement == ".")
{
continue;
}
if (pathElement == "..")
{
if (currentPath.Count != 0)
{
currentPath.Pop();
currentDir = currentPath.Count == 0 ? fileSystem.Root : currentPath.Peek();
}
continue;
}
var foundEntry = await fileSystem.GetEntryByNameAsync(currentDir, pathElement, cancellationToken).ConfigureAwait(false);
if (!(foundEntry is IUnixDirectoryEntry foundDirEntry))
{
return(null);
}
currentPath.Push(foundDirEntry);
currentDir = foundDirEntry;
}
return(currentDir);
}
private IReadOnlyList <IFact> BuildFacts([NotNull] IUnixFileSystem fileSystem, [NotNull] IUnixDirectoryEntry directoryEntry, [NotNull] IUnixFileEntry entry)
{
var result = new List <IFact>()
{
new PermissionsFact(_user, fileSystem, directoryEntry, entry),
new SizeFact(entry.Size),
new TypeFact(entry),
};
if (entry.LastWriteTime.HasValue)
{
result.Add(new ModifyFact(entry.LastWriteTime.Value));
}
if (entry.CreatedTime.HasValue)
{
result.Add(new CreateFact(entry.CreatedTime.Value));
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectoryListingEnumerator"/> class.
/// </summary>
/// <param name="entries">The file system entries to enumerate</param>
/// <param name="fileSystem">The file system of the file system entries</param>
/// <param name="pathEntries">The path entries of the current directory</param>
/// <param name="returnDotEntries"><code>true</code> when this enumerator should return the dot entries</param>
public DirectoryListingEnumerator(IEnumerable<IUnixFileSystemEntry> entries, IUnixFileSystem fileSystem, Stack<IUnixDirectoryEntry> pathEntries, bool returnDotEntries)
{
_pathEntries = pathEntries;
var topPathEntries = pathEntries.Take(3).ToList();
switch (topPathEntries.Count)
{
case 0:
CurrentDirectory = fileSystem.Root;
ParentDirectory = GrandParentDirectory = null;
break;
case 1:
CurrentDirectory = topPathEntries[0];
ParentDirectory = fileSystem.Root;
GrandParentDirectory = null;
break;
case 2:
CurrentDirectory = topPathEntries[0];
ParentDirectory = topPathEntries[1];
GrandParentDirectory = fileSystem.Root;
break;
default:
CurrentDirectory = topPathEntries[0];
ParentDirectory = topPathEntries[1];
GrandParentDirectory = topPathEntries[2];
break;
}
var dotEntries = new List<Tuple<IUnixDirectoryEntry, string>>();
if (returnDotEntries)
{
dotEntries.Add(Tuple.Create(CurrentDirectory, "."));
if (ParentDirectory != null)
dotEntries.Add(Tuple.Create(ParentDirectory, ".."));
}
_dotEntriesEnumerator = dotEntries.GetEnumerator();
_entriesEnumerator = entries.GetEnumerator();
}
private async Task <IFtpResponse?> ExecuteSendAsync(
IFtpDataConnection dataConnection,
ClaimsPrincipal user,
IUnixFileSystem fileSystem,
Stack <IUnixDirectoryEntry> path,
IUnixDirectoryEntry dirEntry,
IMlstFactsFeature factsFeature,
CancellationToken cancellationToken)
{
var encoding = Connection.Features.Get <IEncodingFeature>().Encoding;
var stream = dataConnection.Stream;
using (var writer = new StreamWriter(stream, encoding, 4096, true)
{
NewLine = "\r\n",
})
{
var entries = await fileSystem.GetEntriesAsync(dirEntry, cancellationToken).ConfigureAwait(false);
var enumerator = new DirectoryListingEnumerator(entries, fileSystem, path, true);
var formatter = new FactsListFormatter(user, enumerator, factsFeature.ActiveMlstFacts, false);
while (enumerator.MoveNext())
{
var name = enumerator.Name;
var entry = enumerator.Entry;
var line = formatter.Format(entry, name);
_logger?.LogTrace(line);
await writer.WriteLineAsync(line).ConfigureAwait(false);
}
await writer.FlushAsync().ConfigureAwait(false);
}
// Use 250 when the connection stays open.
return(new FtpResponse(226, T("Closing data connection.")));
}
public FtpDirectory(IUnixFileSystem sys, IDirectory dir) : base(sys, dir)
{
this.dir = dir;
}
public static Task <IUnixDirectoryEntry> GetDirectoryAsync([NotNull] this IUnixFileSystem fileSystem, [NotNull, ItemNotNull] Stack <IUnixDirectoryEntry> currentPath, [CanBeNull] string path, CancellationToken cancellationToken)
{
var pathElements = GetPathElements(path);
return(GetDirectoryAsync(fileSystem, currentPath, pathElements, cancellationToken));
}
/// <summary>
/// Determines whether the <paramref name="pathToTestAsChild"/> is a child or the same path as <paramref name="pathToTestAsParent"/>.
/// </summary>
/// <param name="pathToTestAsChild">The path to test as child.</param>
/// <param name="pathToTestAsParent">The path to test as parent.</param>
/// <param name="fileSystem">The file system to use to compare the file names.</param>
/// <returns><code>true</code> if the <paramref name="pathToTestAsChild"/> is a child or the same path as <paramref name="pathToTestAsParent"/>.</returns>
public static bool IsChildOfOrSameAs([NotNull, ItemNotNull] this Stack <IUnixDirectoryEntry> pathToTestAsChild, [NotNull, ItemNotNull] Stack <IUnixDirectoryEntry> pathToTestAsParent, [NotNull] IUnixFileSystem fileSystem)
{
var fullPathOfParent = pathToTestAsParent.GetFullPath();
var fullPathOfChild = pathToTestAsChild.GetFullPath();
var testPathOfChild = fullPathOfChild.Substring(0, Math.Min(fullPathOfParent.Length, fullPathOfChild.Length));
return(fileSystem.FileSystemEntryComparer.Equals(testPathOfChild, fullPathOfParent) && fullPathOfParent.Length <= fullPathOfChild.Length);
}
public static async Task <SearchResult <IUnixFileSystemEntry> > SearchEntryAsync(this IUnixFileSystem fileSystem, [NotNull, ItemNotNull] Stack <IUnixDirectoryEntry> currentPath, [NotNull, ItemNotNull] IReadOnlyList <string> pathElements, CancellationToken cancellationToken)
{
var sourceDir = await GetDirectoryAsync(fileSystem, currentPath, new ListSegment <string>(pathElements, 0, pathElements.Count - 1), cancellationToken).ConfigureAwait(false);
if (sourceDir == null)
{
return(null);
}
IUnixFileSystemEntry foundEntry;
var fileName = pathElements[pathElements.Count - 1];
switch (fileName)
{
case "":
currentPath.Clear();
fileName = null;
foundEntry = fileSystem.Root;
break;
case ".":
if (currentPath.Count != 0)
{
foundEntry = currentPath.Pop();
fileName = foundEntry.Name;
}
else
{
foundEntry = fileSystem.Root;
fileName = null;
}
break;
case "..":
if (currentPath.Count != 0)
{
currentPath.Pop();
}
if (currentPath.Count != 0)
{
foundEntry = currentPath.Pop();
fileName = foundEntry.Name;
}
else
{
foundEntry = fileSystem.Root;
fileName = null;
}
break;
default:
foundEntry = await fileSystem.GetEntryByNameAsync(sourceDir, fileName, cancellationToken).ConfigureAwait(false);
break;
}
return(new SearchResult <IUnixFileSystemEntry>(sourceDir, foundEntry, fileName));
}
public FtpFile(IUnixFileSystem sys, IFile file) : base(sys, file)
{
this.file = file;
}
/// <summary>
/// Get the directory for the given <paramref name="path"/>.
/// </summary>
/// <param name="fileSystem">The file system to get the directory for.</param>
/// <param name="currentPath">The current path.</param>
/// <param name="path">The (absolute or relative) path to get the directory for.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The found <see cref="IUnixDirectoryEntry"/> or <c>null</c>.</returns>
public static Task <IUnixDirectoryEntry?> GetDirectoryAsync(this IUnixFileSystem fileSystem, Stack <IUnixDirectoryEntry> currentPath, string?path, CancellationToken cancellationToken)
{
var pathElements = GetPathElements(path);
return(GetDirectoryAsync(fileSystem, currentPath, pathElements, cancellationToken));
}
/// <summary>
/// Tries to select the given <paramref name="path"/>.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="pathEntries">The current path (entries).</param>
/// <param name="path">The path to select.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The result of the selection.</returns>
public static async Task <PathSelectionResult> SelectAsync(
this IUnixFileSystem fileSystem,
IEnumerable <IUnixDirectoryEntry> pathEntries,
string?path,
CancellationToken cancellationToken)
{
var currentDirectoryEntries = new Stack <IUnixDirectoryEntry>(pathEntries);
IUnixDirectoryEntry currentDirectoryEntry;
if (currentDirectoryEntries.Count == 0)
{
currentDirectoryEntry = fileSystem.Root;
currentDirectoryEntries.Push(currentDirectoryEntry);
}
else
{
currentDirectoryEntry = currentDirectoryEntries.Peek();
}
var pathSegments = new PathEnumerator(path)
.NormalizePath(GetPathEntryNames(currentDirectoryEntries))
.ToArray();
for (var pathSegmentIndex = 0; pathSegmentIndex != pathSegments.Length; ++pathSegmentIndex)
{
var pathSegment = pathSegments[pathSegmentIndex];
if (pathSegment == "/")
{
currentDirectoryEntries.Clear();
currentDirectoryEntry = fileSystem.Root;
currentDirectoryEntries.Push(currentDirectoryEntry);
continue;
}
var isDirectoryExpected = pathSegment.EndsWith("/");
var childName = isDirectoryExpected ? pathSegment.Substring(0, pathSegment.Length - 1) : pathSegment;
var nextEntry = await fileSystem.GetEntryByNameAsync(
currentDirectoryEntry,
childName,
cancellationToken)
.ConfigureAwait(false);
if (nextEntry == null)
{
// Entry not found
var missingPathSegments = pathSegments.Skip(pathSegmentIndex).ToArray();
var lastIsDirectory = missingPathSegments[missingPathSegments.Length - 1].EndsWith("/");
if (lastIsDirectory)
{
return(PathSelectionResult.CreateMissingDirectory(
currentDirectoryEntries,
missingPathSegments));
}
return(PathSelectionResult.CreateMissingFileOrDirectory(
currentDirectoryEntries,
missingPathSegments));
}
var isDirectory = nextEntry is IUnixDirectoryEntry;
if (isDirectoryExpected && !isDirectory)
{
// File instead of directory found
var missingPathSegments = pathSegments.Skip(pathSegmentIndex).ToArray();
return(PathSelectionResult.CreateMissingDirectory(
currentDirectoryEntries,
missingPathSegments));
}
if (!isDirectory)
{
return(PathSelectionResult.Create(
currentDirectoryEntries,
(IUnixFileEntry)nextEntry));
}
currentDirectoryEntry = (IUnixDirectoryEntry)nextEntry;
currentDirectoryEntries.Push(currentDirectoryEntry);
}
// Found directory
return(PathSelectionResult.Create(
currentDirectoryEntries));
}
protected FtpEntry(IUnixFileSystem sys, IEntry entry)
{
this.sys = sys;
this.entry = entry;
}