public void CreateExecutable_WhenInvoke_ThenCanBeExecutableIsTrue()
{
//Act
var operationInfo = ExecutableInfo.CreateExecutable();
//Assert
Assert.That(operationInfo.CanBeExecuted, Is.True);
}
public void CreateExecutable_WhenInvoke_ThenMessageIsNull()
{
//Act
var operationInfo = ExecutableInfo.CreateExecutable();
//Assert
Assert.That(operationInfo.Message, Is.Null);
}
public ExecutableInfo GetExecutableInfo(double value)
{
if (value < 0)
{
return(ExecutableInfo.CreateNotExecutable(ErrorMessages.InvalidInput));
}
return(ExecutableInfo.CreateExecutable());
}
public ExecutableInfo GetExecutableInfo(double value)
{
if (value == 0.0)
{
return(ExecutableInfo.CreateNotExecutable(ErrorMessages.DivisionOnZero));
}
return(ExecutableInfo.CreateExecutable());
}
public static ExecutableInfo GetExecutableInfo(int index)
{
ExecutableInfo i = default;
if (PortExploits.cracks.TryGetValue(index, out var n) && nameToExeStruct.TryGetValue(n, out i))
{
return(i);
}
return(i);
}
public bool Equals(ExecutableInfo o)
{
return(o.PortNumber == PortNumber &&
o.Number == Number &&
o.NumberIndex == NumberIndex &&
o.Name == Name &&
o.ServiceName == ServiceName &&
o.NeedsPort == NeedsPort &&
o.Data == Data &&
o.LocalData == LocalData);
}
public void CreateNotExecutable_WhenPassMessage_ThenMessageIsTheSame()
{
//Arrange
const string message = "Some message";
//Act
var operationInfo = ExecutableInfo.CreateNotExecutable(message);
//Assert
Assert.That(operationInfo.CanBeExecuted, Is.False);
}
public IExecutable Create(ExecutableInfo executableInfo)
{
var executableType = _executables
.SingleOrDefault(t => t.Name == executableInfo.Name);
if (executableType == null)
{
throw new TypeNotFoundException(executableInfo.Name);
}
return(Create(executableType, executableInfo.Parameters.ToArray()));
}
private void Load()
{
using (var r = new BinaryReader(new SubStream(rootStream, 0))) {
GameTitle = r.ReadUTFString(12);
GameCode = r.Read4C();
MakerCode = r.ReadUTFString(2);
UnitCode = (UnitCodeEnum)r.ReadByte();
r.Skip(1 + 1 + 7 + 1);
Region = (RegionEnum)r.ReadByte();
RomVersion = r.ReadByte();
RomFlags = (RomFlagsEnum)r.ReadByte();
ARM9 = new ExecutableInfo(r.ReadUInt32(), r.ReadUInt32(), r.ReadUInt32(), r.ReadUInt32());
ARM7 = new ExecutableInfo(r.ReadUInt32(), r.ReadUInt32(), r.ReadUInt32(), r.ReadUInt32());
{
uint FNTOffset = r.ReadUInt32();
uint FNTSize = r.ReadUInt32();
uint FATOffset = r.ReadUInt32();
uint FATSize = r.ReadUInt32();
if (FNTSize != 0 && FATSize != 0)
{
FileSystem = new FileSystem(
new SubStream(rootStream, FNTOffset, FNTSize),
new SubStream(rootStream, FATOffset, FATSize),
rootStream
);
}
}
{
uint ARM9OverlayOffset = r.ReadUInt32();
uint ARM9OverlaySize = r.ReadUInt32();
uint ARM7OverlayOffset = r.ReadUInt32();
uint ARM7OverlaySize = r.ReadUInt32();
}
r.Skip(4 * 2);
{
uint bannerOffset = r.ReadUInt32();
Banner = new Banner(new SubStream(rootStream, bannerOffset));
}
UInt16 SecureAreaChecksum = r.ReadUInt16();
UInt16 SecureAreaDelay = r.ReadUInt16();
r.Skip(4 * 2);
}
}
public bool FindPluginInstances(string inAssemblyPath, ref OrderedSet <SimpleDataService> ioImplementers)
{
FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(inAssemblyPath);
Assembly assembly = Assembly.LoadFile(inAssemblyPath);
Type[] exportedTypes = assembly.GetExportedTypes();
Type findType = typeof(BaseWNOSPlugin);
bool addedAny = false;
foreach (Type exportedType in exportedTypes)
{
if (exportedType.IsClass && !exportedType.IsAbstract && findType.IsAssignableFrom(exportedType))
{
ExecutableInfo executableInfo =
new ExecutableInfo(exportedType.Assembly.ManifestModule.Name,
exportedType.FullName);
BaseWNOSPlugin plugin;
try
{
plugin =
AppDomainInstanceLoader.GetInstance <BaseWNOSPlugin>(AppDomain.CurrentDomain, inAssemblyPath,
exportedType.FullName);
}
catch (Exception)
{
continue;
}
SimpleDataService dataService = new SimpleDataService();
if (!CollectionUtils.IsNullOrEmpty(plugin.ConfigurationArguments))
{
dataService.Args = new List <string>(plugin.ConfigurationArguments.Keys);
}
if (!CollectionUtils.IsNullOrEmpty(plugin.DataProviders))
{
dataService.DataSources = new List <string>(plugin.DataProviders.Keys);
}
dataService.Type = PluginLoader.GetServiceType(plugin);
if (dataService.Type != ServiceType.None)
{
dataService.PluginInfo = executableInfo;
dataService.Version = new VersionInfo(fileVersionInfo);
ioImplementers.Add(dataService);
addedAny = true;
}
}
}
return(addedAny);
}
/// <summary>
/// Tries to remove itself from registry startup and then delete the .exe
/// </summary>
/// <returns></returns>
public bool Execute()
{
var execInfo = new ExecutableInfo();
string keyName = @"Software\Microsoft\Windows\CurrentVersion\Run";
using (RegistryKey key = Registry.CurrentUser.OpenSubKey(execInfo.AssemblyName, true))
{
if (key == null)
{
// Key doesn't exist. Do whatever you want to handle
// this case
}
else
{
key.DeleteValue("MyApp");
}
}
execInfo.StartMelt();
Environment.Exit(0);
return(true);
}
private static void SetCachedPath(string toolEntry, string location, ExecutableInfo executableInfo, string minimumToolVersion)
{
SetCachedPath("{0}/{1}/{2}".format(toolEntry, executableInfo, minimumToolVersion), location);
}
public ExecutableInfo GetExecutableInfo(double value1, double value2)
{
return(ExecutableInfo.CreateExecutable());
}
/// <summary>
/// Finds a tool in the file system
/// </summary>
/// <param name="filename">The name of the tool</param>
/// <param name="executableType">Platform or assembly info</param>
/// <param name="minimumVersion">Minimum required version</param>
/// <param name="excludeFilters">A list of tool names which should be excluded from the scan</param>
/// <param name="includeFilters">A list of tool names which should be included in the scan</param>
/// <param name="rememberMissingFile">Disables searching for files which are known to be missing.</param>
/// <param name="tagWithCosmeticVersion"></param>
/// <returns></returns>
public string ScanForFile(string filename, ExecutableInfo executableType = ExecutableInfo.none, string minimumVersion = "0.0",
IEnumerable<string> excludeFilters = null, IEnumerable<string> includeFilters= null, bool rememberMissingFile = false, string tagWithCosmeticVersion = null ) {
if (!IgnoreCache) {
var result = GetCachedPath(filename, executableType, tagWithCosmeticVersion ?? minimumVersion);
if ("NOT-FOUND".Equals(result)) {
if (rememberMissingFile) {
return null; // we've asked to remember that we haven't found this
}
result = null; // we've not asked to remember that, so we'll let it try to find it again.
}
if (!string.IsNullOrEmpty(result)) {
return result;
}
}
Notify("[One moment.. Scanning for utility({0}/{1}/{2})]", filename, executableType.ToString(), tagWithCosmeticVersion ?? minimumVersion);
var ver = VersionStringToUInt64(minimumVersion);
var files = _commonSearchLocations.Union(_searchLocations).SelectMany(
directory => directory.DirectoryEnumerateFilesSmarter("**\\"+filename, SearchOption.TopDirectoryOnly))
.Union(
_recursiveSearchLocations.AsParallel().SelectMany(
directory => directory.DirectoryEnumerateFilesSmarter("**\\"+filename, SearchOption.AllDirectories)));
if (executableType != ExecutableInfo.none || ver != 0) {
files =
files.Where( file =>
(PEInfo.Scan(file).ExecutableInfo & executableType) == executableType &&
PEInfo.Scan(file).FileVersionLong >= ver);
}
if (includeFilters != null) {
files = includeFilters.Aggregate(files, (current, filter) => (from eachFile in current
where eachFile.ToLower().NewIsWildcardMatch(filter.ToLower())
select eachFile));
}
if (excludeFilters != null) {
files = excludeFilters.Aggregate(files, (current, filter) => (from eachFile in current
where !eachFile.ToLower().NewIsWildcardMatch(filter.ToLower())
select eachFile));
}
var filePath = files.MaxElement(each => PEInfo.Scan(each).FileVersionLong);
if (!string.IsNullOrEmpty(filePath) || rememberMissingFile) {
SetCachedPath(filename, string.IsNullOrEmpty(filePath) ? "NOT-FOUND" : filePath , executableType, tagWithCosmeticVersion ?? minimumVersion);
try {
SetCachedPath(filename, string.IsNullOrEmpty(filePath) ? "NOT-FOUND" : filePath, executableType,
PEInfo.Scan(filePath).FileVersion);
} catch {
}
}
return filePath;
}
private static string GetCachedPath(string toolEntry, ExecutableInfo executableInfo, string minimumToolVersion)
{
return(GetCachedPath("{0}/{1}/{2}".format(toolEntry, executableInfo, minimumToolVersion)));
}
/// <summary>
/// Save a tool to the registry
/// </summary>
/// <param name="toolEntry">Name of the tool</param>
/// <param name="location">Full path to the tool</param>
/// <param name="executableInfo">Platform or assembly information</param>
/// <param name="minimumToolVersion"></param>
private static void SetCachedPath(string toolEntry, string location, ExecutableInfo executableInfo, string minimumToolVersion)
{
SetCachedPath("{0}/{1}/{2}".format(toolEntry, executableInfo, minimumToolVersion), location);
}
/// <summary>
/// Finds a tool in the file system
/// </summary>
/// <param name="filename">The name of the tool</param>
/// <param name="executableType">Platform or assembly info</param>
/// <param name="minimumVersion">Minimum required version</param>
/// <param name="excludeFilters">A list of tool names which should be excluded from the scan</param>
/// <param name="includeFilters">A list of tool names which should be included in the scan</param>
/// <param name="rememberMissingFile">Disables searching for files which are known to be missing.</param>
/// <param name="tagWithCosmeticVersion"></param>
/// <returns></returns>
public string ScanForFile(string filename, ExecutableInfo executableType = ExecutableInfo.none, string minimumVersion = "0.0",
IEnumerable <string> excludeFilters = null, IEnumerable <string> includeFilters = null, bool rememberMissingFile = false, string tagWithCosmeticVersion = null)
{
if (!IgnoreCache)
{
var result = GetCachedPath(filename, executableType, tagWithCosmeticVersion ?? minimumVersion);
if ("NOT-FOUND".Equals(result))
{
if (rememberMissingFile)
{
return(null); // we've asked to remember that we haven't found this
}
result = null; // we've not asked to remember that, so we'll let it try to find it again.
}
if (!string.IsNullOrEmpty(result))
{
return(result);
}
}
Notify("[One moment.. Scanning for utility({0}/{1}/{2})]", filename, executableType.ToString(), tagWithCosmeticVersion ?? minimumVersion);
var ver = VersionStringToUInt64(minimumVersion);
var files = _commonSearchLocations.Union(_searchLocations).SelectMany(
directory => directory.DirectoryEnumerateFilesSmarter("**\\" + filename, SearchOption.TopDirectoryOnly))
.Union(
_recursiveSearchLocations.AsParallel().SelectMany(
directory => directory.DirectoryEnumerateFilesSmarter("**\\" + filename, SearchOption.AllDirectories)));
if (executableType != ExecutableInfo.none || ver != 0)
{
files =
files.Where(file =>
(PEInfo.Scan(file).ExecutableInfo & executableType) == executableType &&
PEInfo.Scan(file).FileVersionLong >= ver);
}
if (includeFilters != null)
{
files = includeFilters.Aggregate(files, (current, filter) => (from eachFile in current
where eachFile.ToLower().NewIsWildcardMatch(filter.ToLower())
select eachFile));
}
if (excludeFilters != null)
{
files = excludeFilters.Aggregate(files, (current, filter) => (from eachFile in current
where !eachFile.ToLower().NewIsWildcardMatch(filter.ToLower())
select eachFile));
}
var filePath = files.MaxElement(each => PEInfo.Scan(each).FileVersionLong);
if (!string.IsNullOrEmpty(filePath) || rememberMissingFile)
{
SetCachedPath(filename, string.IsNullOrEmpty(filePath) ? "NOT-FOUND" : filePath, executableType, tagWithCosmeticVersion ?? minimumVersion);
try {
SetCachedPath(filename, string.IsNullOrEmpty(filePath) ? "NOT-FOUND" : filePath, executableType,
PEInfo.Scan(filePath).FileVersion);
} catch {
}
}
return(filePath);
}
/// <summary>
/// Finds a tool in the file system
/// </summary>
/// <param name="filename">The name of the tool</param>
/// <param name="executableType">Platform or assembly information</param>
/// <param name="filters">A list of tool names which should be excluded from the scan</param>
/// <returns></returns>
public string ScanForFile(string filename, ExecutableInfo executableType, IEnumerable <string> filters)
{
return(ScanForFile(filename, executableType, "0.0", filters));
}
public string ScanForFile(string filename, ExecutableInfo executableType, IEnumerable<string> filters)
{
return ScanForFile(filename, executableType, "0.0", filters);
}
public string ScanForFile(string filename, ExecutableInfo executableType = ExecutableInfo.none, string minimumVersion = "0.0", IEnumerable<string> filters = null)
{
if (!IgnoreCache) {
string result = GetCachedPath(filename, executableType, minimumVersion);
if (!string.IsNullOrEmpty(result))
return result;
}
var ver = minimumVersion.VersionStringToUInt64();
var files = commonSearchLocations.Union(searchLocations).AsParallel().SelectMany(
directory => directory.DirectoryEnumerateFilesSmarter(filename, SearchOption.TopDirectoryOnly))
.Union(
recursiveSearchLocations.AsParallel().SelectMany(
directory => directory.DirectoryEnumerateFilesSmarter(filename, SearchOption.AllDirectories)));
files = files.Where(file => (GetExeType(file) & executableType) == executableType && GetToolVersionNumeric(file) >= ver);
if( filters != null ) {
files = filters.Aggregate(files, (current, filter) => (from eachFile in current
where !eachFile.IsWildcardMatch(filter)
select eachFile));
}
var filePath = files.MaxElement(GetToolVersionNumeric);
if (!string.IsNullOrEmpty(filePath)) {
SetCachedPath(filename, filePath, executableType, minimumVersion);
SetCachedPath(filename, filePath, executableType, GetToolVersion(filePath));
}
return filePath;
}
private static string GetCachedPath(string toolEntry, ExecutableInfo executableInfo, string minimumToolVersion)
{
return GetCachedPath("{0}/{1}/{2}".format(toolEntry, executableInfo, minimumToolVersion));
}
