protected override void BeginProcessing()
{
if (_path == null)
{
_path = new string[] { @".\" };
}
if (force)
{
priv = new Alphaleonis.Win32.Security.PrivilegeEnabler(Alphaleonis.Win32.Security.Privilege.Backup);
}
dopt = DirectoryEnumerationOptions.BasicSearch | DirectoryEnumerationOptions.ContinueOnException | DirectoryEnumerationOptions.LargeCache;
if (recurse)
{
dopt |= DirectoryEnumerationOptions.Recursive;
}
if (directory && !file)
{
dopt |= DirectoryEnumerationOptions.Folders;
}
else if (file && !directory)
{
dopt |= DirectoryEnumerationOptions.Files;
}
else
{
dopt |= DirectoryEnumerationOptions.FilesAndFolders;
}
}
public static IEnumerable <string> EnumerateDirectories(string path, DirectoryEnumerationOptions options)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Files; // Remove enumeration of files.
options |= DirectoryEnumerationOptions.Folders; // Add enumeration of directories.
return(EnumerateFileSystemEntryInfosCore <string>(null, path, Path.WildcardStarMatchAll, options, PathFormat.RelativePath));
}
public IEnumerable <FileInfo> EnumerateFiles(DirectoryEnumerationOptions options)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Folders;
options |= DirectoryEnumerationOptions.Files;
return(Directory.EnumerateFileSystemEntryInfosCore <FileInfo>(Transaction, LongFullName, Path.WildcardStarMatchAll, options, PathFormat.LongFullPath));
}
public IEnumerable <FileInfo> EnumerateFiles(string searchPattern, DirectoryEnumerationOptions options)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Folders;
options |= DirectoryEnumerationOptions.Files;
return(Directory.EnumerateFileSystemEntryInfosCore <FileInfo>(Transaction, LongFullName, searchPattern, options, PathFormat.LongFullPath));
}
public static IEnumerable <string> EnumerateDirectories(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Files;
options |= DirectoryEnumerationOptions.Folders;
return(EnumerateFileSystemEntryInfosCore <string>(null, path, Path.WildcardStarMatchAll, options, pathFormat));
}
private static IEnumerable <string> GetPathsUsingAlphaFs(PathSearchOptions searchOptions)
{
DirectoryEnumerationOptions options = (DirectoryEnumerationOptions)searchOptions.TypesToGet |
DirectoryEnumerationOptions.ContinueOnException | DirectoryEnumerationOptions.SkipReparsePoints;
if (searchOptions.SearchOption == SearchOption.AllDirectories)
{
options |= DirectoryEnumerationOptions.Recursive;
}
var paths = Directory.EnumerateFileSystemEntries(searchOptions.RootDirectory, searchOptions.SearchPattern, options);
return(paths);
}
public static void Compress(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, null, true, pathFormat);
}
public long CountFileSystemObjects(string searchPattern, DirectoryEnumerationOptions options)
{
return(Directory.EnumerateFileSystemEntryInfosCore <string>(Transaction, LongFullName, searchPattern, options, PathFormat.LongFullPath).Count());
}
public static Dictionary <string, long> GetProperties(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return(GetPropertiesInternal(null, path, options, pathFormat));
}
public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
{
CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, null, true, PathFormat.RelativePath);
}
public long CountFileSystemObjects(string searchPattern, DirectoryEnumerationOptions options)
{
return Directory.EnumerateFileSystemEntryInfosInternal<string>(Transaction, LongFullName, searchPattern, options, PathFormat.LongFullPath).Count();
}
public static Dictionary<string, long> GetProperties(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return GetPropertiesInternal(null, path, options, pathFormat);
}
public static IEnumerable <T> EnumerateFileSystemEntryInfosTransacted <T>(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return(EnumerateFileSystemEntryInfosCore <T>(transaction, path, Path.WildcardStarMatchAll, options, pathFormat));
}
public static long CountFileSystemObjects(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
{
return EnumerateFileSystemEntryInfosInternal<string>(transaction, path, Path.WildcardStarMatchAll, options, PathFormat.RelativePath).Count();
}
internal static void CompressDecompressInternal(KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions options, bool compress, PathFormat pathFormat)
{
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
// Process directories and files.
foreach (var fso in EnumerateFileSystemEntryInfosInternal<string>(transaction, pathLp, searchPattern, options | DirectoryEnumerationOptions.AsLongPath, PathFormat.LongFullPath))
Device.ToggleCompressionInternal(true, transaction, fso, compress, PathFormat.LongFullPath);
// Compress the root directory, the given path.
Device.ToggleCompressionInternal(true, transaction, pathLp, compress, PathFormat.LongFullPath);
}
public static void Compress(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
CompressDecompressInternal(null, path, Path.WildcardStarMatchAll, options, true, pathFormat);
}
public static void Decompress(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
CompressDecompressInternal(transaction, path, Path.WildcardStarMatchAll, options, false, pathFormat);
}
public static void Decompress(string path, DirectoryEnumerationOptions options)
{
CompressDecompressInternal(null, path, Path.WildcardStarMatchAll, options, false, PathFormat.RelativePath);
}
public static void Compress(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
{
CompressDecompressInternal(transaction, path, Path.WildcardStarMatchAll, options, true, PathFormat.RelativePath);
}
public void Decompress(DirectoryEnumerationOptions options)
{
Directory.CompressDecompressInternal(Transaction, LongFullName, Path.WildcardStarMatchAll, options, false, PathFormat.LongFullPath);
}
public static long CountFileSystemObjects(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return EnumerateFileSystemEntryInfosInternal<string>(null, path, Path.WildcardStarMatchAll, options, pathFormat).Count();
}
internal static Dictionary<string, long> GetPropertiesInternal(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
const string propFile = "File";
const string propTotal = "Total";
const string propSize = "Size";
long total = 0;
long size = 0;
Type typeOfAttrs = typeof(FileAttributes);
Array attributes = Enum.GetValues(typeOfAttrs);
Dictionary<string, long> props = Enum.GetNames(typeOfAttrs).OrderBy(attrs => attrs).ToDictionary<string, string, long>(name => name, name => 0);
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
foreach (FileSystemEntryInfo fsei in EnumerateFileSystemEntryInfosInternal<FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, options, PathFormat.LongFullPath))
{
total++;
if (!fsei.IsDirectory)
size += fsei.FileSize;
foreach (FileAttributes attributeMarker in attributes)
{
// Marker exists in flags.
if ((fsei.Attributes & attributeMarker) == attributeMarker)
// Regular directory that will go to stack, adding directory flag ++
props[(((attributeMarker & FileAttributes.Directory) == FileAttributes.Directory) ? FileAttributes.Directory : attributeMarker).ToString()]++;
}
}
// Adjust regular files count.
props.Add(propFile, total - props[FileAttributes.Directory.ToString()] - props[FileAttributes.ReparsePoint.ToString()]);
props.Add(propTotal, total);
props.Add(propSize, size);
return props;
}
private static void DoWork(string f, string r, string d, string csv, string dt, bool debug, bool trace)
{
var levelSwitch = new LoggingLevelSwitch();
var template = "{Message:lj}{NewLine}{Exception}";
if (debug)
{
levelSwitch.MinimumLevel = LogEventLevel.Debug;
template = "[{Timestamp:HH:mm:ss.fff} {Level:u3}] {Message:lj}{NewLine}{Exception}";
}
if (trace)
{
levelSwitch.MinimumLevel = LogEventLevel.Verbose;
template = "[{Timestamp:HH:mm:ss.fff} {Level:u3}] {Message:lj}{NewLine}{Exception}";
}
var conf = new LoggerConfiguration()
.WriteTo.Console(outputTemplate: template)
.MinimumLevel.ControlledBy(levelSwitch);
Log.Logger = conf.CreateLogger();
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.WriteLine();
Log.Fatal("Non-Windows platforms not supported due to the need to load ESI specific Windows libraries! Exiting...");
Console.WriteLine();
Environment.Exit(0);
return;
}
if (f.IsNullOrEmpty() && d.IsNullOrEmpty())
{
var helpBld = new HelpBuilder(LocalizationResources.Instance, Console.WindowWidth);
var hc = new HelpContext(helpBld, _rootCommand, Console.Out);
helpBld.Write(hc);
Log.Warning("Either -f or -d is required. Exiting\r\n");
return;
}
if (f.IsNullOrEmpty() == false && !File.Exists(f))
{
Log.Warning("File '{File}' not found. Exiting", f);
return;
}
if (d.IsNullOrEmpty() == false && !Directory.Exists(d))
{
Log.Warning("Directory '{D}' not found. Exiting", d);
return;
}
if (csv.IsNullOrEmpty())
{
var helpBld = new HelpBuilder(LocalizationResources.Instance, Console.WindowWidth);
var hc = new HelpContext(helpBld, _rootCommand, Console.Out);
helpBld.Write(hc);
Log.Warning("--csv is required. Exiting\r\n");
return;
}
Log.Information("{Header}", Header);
Console.WriteLine();
Log.Information("Command line: {Args}\r\n", string.Join(" ", _args));
if (IsAdministrator() == false)
{
Log.Warning("Warning: Administrator privileges not found!\r\n");
}
var sw = new Stopwatch();
sw.Start();
var ts = DateTimeOffset.UtcNow;
Srum sr = null;
if (d.IsNullOrEmpty() == false)
{
IEnumerable <string> files2;
#if NET6_0
var enumerationOptions = new EnumerationOptions
{
IgnoreInaccessible = true,
MatchCasing = MatchCasing.CaseInsensitive,
RecurseSubdirectories = true,
AttributesToSkip = 0
};
files2 =
Directory.EnumerateFileSystemEntries(d, "SRUDB.DAT", enumerationOptions);
f = files2.FirstOrDefault();
if (f.IsNullOrEmpty())
{
Log.Warning("Did not locate any files named 'SRUDB.dat'! Exiting");
return;
}
Log.Information("Found SRUM database file '{F}'!", f);
files2 =
Directory.EnumerateFileSystemEntries(d, "SOFTWARE", enumerationOptions);
r = files2.FirstOrDefault();
if (r.IsNullOrEmpty())
{
Log.Warning("Did not locate any files named 'SOFTWARE'! Registry data will not be extracted");
}
else
{
Log.Information("Found SOFTWARE hive '{R}'!", r);
}
#elif NET462
//kape mode, so find the files
var ilter = new DirectoryEnumerationFilters();
ilter.InclusionFilter = fsei =>
{
if (fsei.FileSize == 0)
{
return(false);
}
if (fsei.FileName.ToUpperInvariant() == "SRUDB.DAT")
{
return(true);
}
return(false);
};
ilter.RecursionFilter = entryInfo => !entryInfo.IsMountPoint && !entryInfo.IsSymbolicLink;
ilter.ErrorFilter = (errorCode, errorMessage, pathProcessed) => true;
const DirectoryEnumerationOptions dirEnumOptions =
DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive |
DirectoryEnumerationOptions.SkipReparsePoints | DirectoryEnumerationOptions.ContinueOnException |
DirectoryEnumerationOptions.BasicSearch;
files2 =
Directory.EnumerateFileSystemEntries(d, dirEnumOptions, ilter);
f = files2.FirstOrDefault();
if (f.IsNullOrEmpty())
{
Log.Warning("Did not locate any files named 'SRUDB.dat'! Exiting");
return;
}
Log.Information("Found SRUM database file '{F}'!", f);
ilter = new DirectoryEnumerationFilters();
ilter.InclusionFilter = fsei =>
{
if (fsei.FileSize == 0)
{
return(false);
}
if (fsei.FileName.ToUpperInvariant() == "SOFTWARE")
{
return(true);
}
return(false);
};
ilter.RecursionFilter = entryInfo => !entryInfo.IsMountPoint && !entryInfo.IsSymbolicLink;
ilter.ErrorFilter = (errorCode, errorMessage, pathProcessed) => true;
files2 =
Directory.EnumerateFileSystemEntries(d, dirEnumOptions, ilter);
r = files2.FirstOrDefault();
if (r.IsNullOrEmpty())
{
Log.Warning("Did not locate any files named 'SOFTWARE'! Registry data will not be extracted");
}
else
{
Log.Information("Found SOFTWARE hive '{R}'!", r);
}
#endif
Console.WriteLine();
}
try
{
Log.Information("Processing '{F}'...", f);
sr = new Srum(f, r);
Console.WriteLine();
Log.Information("Processing complete!");
Console.WriteLine();
Log.Information("{EnergyUse} {EnergyUsagesCount:N0}", "Energy Usage count:".PadRight(30),
sr.EnergyUsages.Count);
Log.Information("{Unknown312s} {Unknown312sCount:N0}", "Unknown 312 count:".PadRight(30),
sr.TimelineProviders.Count);
Log.Information("{UnknownD8Fs} {UnknownD8FsCount:N0}", "Unknown D8F count:".PadRight(30),
sr.Vfuprovs.Count);
Log.Information("{AppResourceUseInfos} {AppResourceUseInfosCount:N0}",
"App Resource Usage count:".PadRight(30), sr.AppResourceUseInfos.Count);
Log.Information("{NetworkConnections} {NetworkConnectionsCount:N0}",
"Network Connection count:".PadRight(30), sr.NetworkConnections.Count);
Log.Information("{NetworkUsages} {NetworkUsagesCount}", "Network Usage count:".PadRight(30),
sr.NetworkUsages.Count);
Log.Information("{PushNotifications} {PushNotificationsCount:N0}", "Push Notification count:".PadRight(30),
sr.PushNotifications.Count);
Console.WriteLine();
}
catch (Exception e)
{
Log.Error(e,
"Error processing file! Message: {Message}.\r\n\r\nThis almost always means the database is dirty and must be repaired. This can be verified by running 'esentutl.exe /mh SRUDB.dat' and examining the 'State' property",
e.Message);
Console.WriteLine();
Log.Information(
"If the database is dirty, **make a copy of your files**, ensure all files in the directory are not Read-only, open a PowerShell session as an admin, and repair by using the following commands (change directories to the location of SRUDB.dat first):\r\n\r\n'esentutl.exe /r sru /i'\r\n'esentutl.exe /p SRUDB.dat'\r\n\r\n");
Environment.Exit(0);
}
if (csv.IsNullOrEmpty() == false)
{
if (Directory.Exists(csv) == false)
{
Log.Information(
"Path to '{Csv}' doesn't exist. Creating...", csv);
try
{
Directory.CreateDirectory(csv);
}
catch (Exception)
{
Log.Fatal(
"Unable to create directory '{Csv}'. Does a file with the same name exist? Exiting", csv);
return;
}
}
string outName;
string outFile;
Log.Information("CSV output will be saved to '{Csv}'\r\n", csv);
StreamWriter swCsv;
CsvWriter csvWriter;
try
{
Log.Debug("Dumping Energy Usage tables '{TableName}'", EnergyUsage.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_EnergyUsage_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <EnergyUsage>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
foo.Map(t => t.EventTimestamp).Convert(t =>
$"{t.Value.EventTimestamp?.ToString(dt)}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <EnergyUsage>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.EnergyUsages.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'EnergyUsage' data! Error: {Message}", e.Message);
}
try
{
Log.Debug("Dumping Unknown 312 table '{TableName}'", TimelineProvider.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_Unknown312_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <TimelineProvider>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
foo.Map(t => t.EndTime).Convert(t =>
$"{t.Value.EndTime.ToString(dt)}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <TimelineProvider>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.TimelineProviders.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'Unknown312' data! Error: {Message}", e.Message);
}
try
{
Log.Debug("Dumping Unknown D8F table '{TableName}'", Vfuprov.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_UnknownD8F_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <Vfuprov>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
foo.Map(t => t.EndTime).Convert(t =>
$"{t.Value.EndTime.ToString(dt)}");
foo.Map(t => t.StartTime).Convert(t =>
$"{t.Value.StartTime.ToString(dt)}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <Vfuprov>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.Vfuprovs.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'UnknownD8F' data! Error: {Message}", e.Message);
}
try
{
Log.Debug("Dumping App Resource Use Info table '{TableName}'", AppResourceUseInfo.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_AppResourceUseInfo_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <AppResourceUseInfo>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <AppResourceUseInfo>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.AppResourceUseInfos.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'AppResourceUseInfo' data! Error: {Message}", e.Message);
}
try
{
Log.Debug("Dumping Network Connection table '{TableName}'", NetworkConnection.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_NetworkConnections_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <NetworkConnection>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
foo.Map(t => t.ConnectStartTime).Convert(t =>
$"{t.Value.ConnectStartTime.ToString(dt)}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <NetworkConnection>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.NetworkConnections.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'NetworkConnection' data! Error: {Message}", e.Message);
}
try
{
Log.Debug("Dumping Network Usage table '{TableName}'", NetworkUsage.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_NetworkUsages_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <NetworkUsage>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <NetworkUsage>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.NetworkUsages.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'NetworkUsage' data! Error: {Message}", e.Message);
}
try
{
Log.Debug("Dumping Push Notification table '{TableName}'", PushNotification.TableName);
outName = $"{ts:yyyyMMddHHmmss}_SrumECmd_PushNotifications_Output.csv";
outFile = Path.Combine(csv, outName);
swCsv = new StreamWriter(outFile, false, Encoding.UTF8);
csvWriter = new CsvWriter(swCsv, CultureInfo.InvariantCulture);
var foo = csvWriter.Context.AutoMap <PushNotification>();
foo.Map(t => t.Timestamp).Convert(t =>
$"{t.Value.Timestamp:yyyy-MM-dd HH:mm:ss}");
csvWriter.Context.RegisterClassMap(foo);
csvWriter.WriteHeader <PushNotification>();
csvWriter.NextRecord();
csvWriter.WriteRecords(sr.PushNotifications.Values);
csvWriter.Flush();
swCsv.Flush();
}
catch (Exception e)
{
Log.Error(e, "Error exporting 'PushNotification' data! Error: {Message}", e.Message);
}
sw.Stop();
Log.Information("Processing completed in {TotalSeconds:N4} seconds\r\n", sw.Elapsed.TotalSeconds);
}
}
public static long CountFileSystemObjects(KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions options)
{
return EnumerateFileSystemEntryInfosInternal<string>(transaction, path, searchPattern, options, PathFormat.RelativePath).Count();
}
public long CountFileSystemObjects(DirectoryEnumerationOptions options)
{
return Directory.EnumerateFileSystemEntryInfosInternal<string>(Transaction, LongFullName, Path.WildcardStarMatchAll, options, PathFormat.LongFullPath).Count();
}
public static long CountFileSystemObjects(string path, string searchPattern, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return EnumerateFileSystemEntryInfosInternal<string>(null, path, searchPattern, options, pathFormat).Count();
}
public static IEnumerable <string> EnumerateDirectoriesTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Files;
options |= DirectoryEnumerationOptions.Folders;
return(EnumerateFileSystemEntryInfosCore <string>(transaction, path, Path.WildcardStarMatchAll, options, PathFormat.RelativePath));
}
public static IEnumerable <T> EnumerateFileSystemEntryInfosTransacted <T>(KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return(EnumerateFileSystemEntryInfosCore <T>(transaction, path, searchPattern, options, pathFormat));
}
public static Dictionary <string, long> GetProperties(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
{
return(GetPropertiesInternal(transaction, path, options, PathFormat.RelativePath));
}
public static IEnumerable <string> EnumerateDirectories(string path, string searchPattern, DirectoryEnumerationOptions options)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Files;
options |= DirectoryEnumerationOptions.Folders;
return(EnumerateFileSystemEntryInfosCore <string>(null, path, searchPattern, options, PathFormat.RelativePath));
}
internal static IEnumerable <T> EnumerateFileSystemEntryInfosCore <T>(KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
// Enable BasicSearch and LargeCache by default.
options |= DirectoryEnumerationOptions.BasicSearch | DirectoryEnumerationOptions.LargeCache;
return(new FindFileSystemEntryInfo(true, transaction, path, searchPattern, options, typeof(T), pathFormat).Enumerate <T>());
}
public static IEnumerable <string> EnumerateDirectoriesTransacted(KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
// Adhere to the method name.
options &= ~DirectoryEnumerationOptions.Files;
options |= DirectoryEnumerationOptions.Folders;
return(EnumerateFileSystemEntryInfosCore <string>(transaction, path, searchPattern, options, pathFormat));
}
internal static Dictionary <string, long> GetPropertiesCore(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
long total = 0;
long size = 0;
const string propFile = "File";
const string propTotal = "Total";
const string propSize = "Size";
var typeOfAttrs = typeof(FileAttributes);
var attributes = Enum.GetValues(typeOfAttrs);
var props = Enum.GetNames(typeOfAttrs).OrderBy(attrs => attrs).ToDictionary <string, string, long>(name => name, name => 0);
var pathLp = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
foreach (var fsei in EnumerateFileSystemEntryInfosCore <FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, options, PathFormat.LongFullPath))
{
total++;
if (!fsei.IsDirectory)
{
size += fsei.FileSize;
}
var fsei1 = fsei;
foreach (var attributeMarker in attributes.Cast <FileAttributes>().Where(attributeMarker => (fsei1.Attributes & attributeMarker) != 0))
{
props[((attributeMarker & FileAttributes.Directory) != 0 ? FileAttributes.Directory : attributeMarker).ToString()]++;
}
}
// Adjust regular files count.
props.Add(propFile, total - props[FileAttributes.Directory.ToString()] - props[FileAttributes.ReparsePoint.ToString()]);
props.Add(propTotal, total);
props.Add(propSize, size);
return(props);
}
internal static Dictionary <string, long> GetPropertiesInternal(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
const string propFile = "File";
const string propTotal = "Total";
const string propSize = "Size";
long total = 0;
long size = 0;
Type typeOfAttrs = typeof(FileAttributes);
Array attributes = Enum.GetValues(typeOfAttrs);
Dictionary <string, long> props = Enum.GetNames(typeOfAttrs).OrderBy(attrs => attrs).ToDictionary <string, string, long>(name => name, name => 0);
string pathLp = Path.GetExtendedLengthPathInternal(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
foreach (FileSystemEntryInfo fsei in EnumerateFileSystemEntryInfosInternal <FileSystemEntryInfo>(transaction, pathLp, Path.WildcardStarMatchAll, options, PathFormat.LongFullPath))
{
total++;
if (!fsei.IsDirectory)
{
size += fsei.FileSize;
}
foreach (FileAttributes attributeMarker in attributes)
{
// Marker exists in flags.
if ((fsei.Attributes & attributeMarker) == attributeMarker)
{
// Regular directory that will go to stack, adding directory flag ++
props[(((attributeMarker & FileAttributes.Directory) == FileAttributes.Directory) ? FileAttributes.Directory : attributeMarker).ToString()]++;
}
}
}
// Adjust regular files count.
props.Add(propFile, total - props[FileAttributes.Directory.ToString()] - props[FileAttributes.ReparsePoint.ToString()]);
props.Add(propTotal, total);
props.Add(propSize, size);
return(props);
}
public void Compress(DirectoryEnumerationOptions options)
{
Directory.CompressDecompressInternal(Transaction, LongFullName, Path.WildcardStarMatchAll, options, true, PathFormat.LongFullPath);
}
public static void Compress(string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters)
{
CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, filters, true, PathFormat.RelativePath);
}
public static Dictionary <string, long> GetProperties(string path, DirectoryEnumerationOptions options)
{
return(GetPropertiesCore(null, path, options, PathFormat.RelativePath));
}
public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters, PathFormat pathFormat)
{
CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, filters, true, pathFormat);
}
public static Dictionary <string, long> GetPropertiesTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
{
return(GetPropertiesCore(transaction, path, options, pathFormat));
}
public long CountFileSystemObjects(DirectoryEnumerationOptions options)
{
return(Directory.EnumerateFileSystemEntryInfosCore <string>(Transaction, LongFullName, Path.WildcardStarMatchAll, options, PathFormat.LongFullPath).Count());
}
public IEnumerable <FileInfo> EnumerateFiles(DirectoryEnumerationOptions options)
{
return(Directory.EnumerateFileSystemEntryInfosCore <FileInfo>(false, Transaction, LongFullName, Path.WildcardStarMatchAll, null, options, null, PathFormat.LongFullPath));
}
public IEnumerable <FileInfo> EnumerateFiles(string searchPattern, DirectoryEnumerationOptions options)
{
return(Directory.EnumerateFileSystemEntryInfosCore <FileInfo>(false, Transaction, LongFullName, searchPattern, null, options, null, PathFormat.LongFullPath));
}
public void Decompress(DirectoryEnumerationOptions options)
{
Directory.CompressDecompressCore(Transaction, LongFullName, Path.WildcardStarMatchAll, options, false, PathFormat.LongFullPath);
}
public FindFileSystemEntryInfo(bool isFolder, KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions options, Type typeOfT, PathFormat pathFormat)
{
Transaction = transaction;
OriginalInputPath = path;
InputPath = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
IsRelativePath = !Path.IsPathRooted(OriginalInputPath, false);
// .NET behaviour.
SearchPattern = searchPattern.TrimEnd(Path.TrimEndChars);
FileSystemObjectType = null;
ContinueOnException = (options & DirectoryEnumerationOptions.ContinueOnException) != 0;
AsLongPath = (options & DirectoryEnumerationOptions.AsLongPath) != 0;
AsString = typeOfT == typeof(string);
AsFileSystemInfo = !AsString && (typeOfT == typeof(FileSystemInfo) || typeOfT.BaseType == typeof(FileSystemInfo));
FindExInfoLevel = NativeMethods.IsAtLeastWindows7 && (options & DirectoryEnumerationOptions.BasicSearch) != 0
? NativeMethods.FINDEX_INFO_LEVELS.Basic
: NativeMethods.FINDEX_INFO_LEVELS.Standard;
LargeCache = NativeMethods.IsAtLeastWindows7 && (options & DirectoryEnumerationOptions.LargeCache) != 0
? NativeMethods.FindExAdditionalFlags.LargeFetch
: NativeMethods.FindExAdditionalFlags.None;
IsDirectory = isFolder;
if (IsDirectory)
{
// Need files or folders to enumerate.
if ((options & DirectoryEnumerationOptions.FilesAndFolders) == DirectoryEnumerationOptions.None)
{
options |= DirectoryEnumerationOptions.FilesAndFolders;
}
FileSystemObjectType = (options & DirectoryEnumerationOptions.FilesAndFolders) == DirectoryEnumerationOptions.FilesAndFolders
? (bool?)null
: (options & DirectoryEnumerationOptions.Folders) != 0;
Recursive = (options & DirectoryEnumerationOptions.Recursive) != 0;
SkipReparsePoints = (options & DirectoryEnumerationOptions.SkipReparsePoints) != 0;
}
}
public static Dictionary<string, long> GetProperties(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
{
return GetPropertiesInternal(transaction, path, options, PathFormat.RelativePath);
}
