private void Load()
{
if (!_loaded)
{
_loaded = true;
if (File.Exists(_nsroot))
{
using (FileStream fs = new FileStream(_nsroot, FileMode.Open))
using (ZipArchive zip = new ZipArchive(fs, ZipArchiveMode.Read))
{
var ent = zip.GetEntry(Fullname);
if (ent != null)
{
using (var sr = new StreamReader(ent.Open()))
{
var xe = XElement.Load(sr);
foreach (var e in xe.Element("Types").Elements("Type"))
{
Types.Add(Item.Parse <Type>(e));
}
foreach (var e in xe.Element("ExtensionTypes").Elements("Type"))
{
ExtensionTypes.Add(Item.Parse <Type>(e));
}
SetTo(Types);
SetTo(ExtensionTypes);
}
}
}
}
}
}
private void GetAllExtensionFilesHelper(string target, List <string> ret)
{
if (target.Length > MaxPathLength)
{
//For some awful reason, Directory.Exists fails if the path is too long.
return;
}
if (!Directory.Exists(target))
{
Reporter.Report("Directory " + target + " does not exist.");
return;
}
foreach (
var curExt in
ExtensionTypes.Split(',').Select(x => x.Trim().Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
{
var allCurFiles = Directory.GetFiles(target).Where(x => Path.GetExtension(x).ToLower().Equals(curExt));
ret.AddRange(allCurFiles);
}
foreach (var cur in Directory.GetDirectories(target))
{
try
{
GetAllExtensionFilesHelper(cur, ret);
}
catch (Exception)
{
}
}
}
public Type GetExtype(string name, bool create = false)
{
var names = name.Split('.');
if (!ExtensionTypes.ContainsKey(names[0]))
{
if (create)
{
ExtensionTypes.Add(new Type(this, null, names[0]));
}
else
{
return(null);
}
}
var type = ExtensionTypes[names[0]];
foreach (var tname in names.Skip(1))
{
if (!type.Types.ContainsKey(tname))
{
if (create)
{
type.Types.Add(new Type(this, type, tname));
}
else
{
return(null);
}
}
type = type.Types[tname];
}
return(type);
}
public TestExtensionS2Settings(MessageTypes msgType, ExtensionTypes extensionType, ExtensionAppliedActions appliedAction)
: this()
{
MessageTypeV = msgType;
ExtensionTypeV = extensionType;
ActionV = appliedAction;
Counter = new ValueEntity <int>();
}
/// <summary>
/// Locates the best match overload to utilize given a set of method call arguments.
/// </summary>
/// <typeparam name = "T">
/// The type of objects to return, this should be either MethodInfo or ConstructorInfo.
/// </typeparam>
/// <param name = "type">
/// The type for which the method should be located.
/// </param>
/// <param name = "name">
/// The name of the method to locate (can be null for constructors).
/// </param>
/// <param name = "nullType">
/// The type to "assume" for any inbound parameter that is null.
/// </param>
/// <param name = "bindings">
/// The BindingFlags to use when locating methods.
/// </param>
/// <param name = "parameters">
/// The parameters to use when locating methods overloads.
/// </param>
/// <param name="typeParameters">
/// The type Parameters to be used with a generic method.
/// </param>
/// <returns>
/// A MethodBase (of type T) representing the "best match" method to use for the supplied
/// parameters.
/// </returns>
private static T LocateBestMatch <T>(Type type, string name, Type nullType, BindingFlags bindings, object[] parameters, Type[] typeParameters)
where T : MethodBase
{
IEnumerable <T> infos = null;
IEnumerable <T> extensions = null;
if (typeof(MethodInfo).IsAssignableFrom(typeof(T)))
{
IEnumerable <MethodInfo> methods = type.GetMethods(bindings).Where(x => x.Name == name);
IEnumerable <MethodInfo> extensionMethods =
ExtensionTypes.SelectMany(t => t.GetMethods()).Where(m => m.IsDefined(typeof(ExtensionAttribute), true));
IEnumerable <MethodInfo> sameNamedExtensionMethods = extensionMethods.Where(m => m.Name == name);
extensions = sameNamedExtensionMethods.Where(m => m.GetParameters()[0].ParameterType.IsAssignableFrom(type)).Cast <T>();
infos = methods.Cast <T>();
}
else if (typeof(ConstructorInfo).IsAssignableFrom(typeof(T)))
{
ConstructorInfo[] constructors = type.GetConstructors(bindings);
infos = constructors.Cast <T>();
}
T bestMatch = null;
int bestScore = 0;
// Attempt the find the best match for the method.
foreach (T info in infos)
{
// This is used to "score" the best constructor to call.
// This avoids unnecessary ambiguity errors when multiple members
// "could work".
int score = CompareTypeAssignments(info.GetParameters(), parameters, nullType, typeParameters);
if (score > bestScore)
{
bestScore = score;
bestMatch = info;
}
}
// If no match, try to find a match from an extension method.
if (bestMatch.IsNull() && extensions.IsNotNull() && typeof(MethodInfo).IsAssignableFrom(typeof(T)))
{
foreach (T info in extensions)
{
// This is used to "score" the best constructor to call.
// This avoids unnecessary ambiguity errors when multiple members
// "could work".
int score = CompareTypeAssignments(info.GetParameters().Skip(1).ToArray(), parameters, nullType, null);
if (score > bestScore)
{
bestScore = score;
bestMatch = info;
}
}
}
return(bestMatch);
}
public bool IsExtensionAllowed(string fileName)
{
if (ExtensionTypes.Any())
{
var file = Path.GetExtension(fileName);
return(ExtensionTypes.Any(x => x.IsEqual(file)));
}
return(true);
}
public BookSearchViewModel()
{
SelectedExtension = ExtensionTypes.FirstOrDefault();
Drives = new ObservableCollection <string>(GetAllDrives());
Drives.Insert(0, "Cały dysk");
SelectedLocation = Drives.FirstOrDefault();
SearchCommand = new RelayCommand(OnSearch);
SelectCommand = new RelayCommand(OnSelect);
SettingsCommand = new RelayCommand(OnSettings);
MoveCommand = new RelayCommand(OnMove);
DeleteDuplicatesCommand = new RelayCommand(OnDeleteDuplicates);
CancelSearchCommand = new RelayCommand(OnCancelSearch);
}
public DayExtensions GetNewInstance(DayExtensions dayExtensions, ExtensionTypes extensionTypes)
{
return(new DayExtensions
{
AffectationDate = dayExtensions.AffectationDate,
CreatedAt = DateTimeOffset.Now,
ExtensionType = extensionTypes,
ExtensionTypeId = dayExtensions.ExtensionTypeId,
HoursNumber = dayExtensions.HoursNumber,
PersonsId = dayExtensions.PersonsId,
State = dayExtensions.State,
RequestDate = DateTime.Now,
ModificatedAt = DateTimeOffset.Now,
});
}
/// <summary>Finds mime type using provided extension and/or file's binary content.</summary>
/// <param name="file">Full file path</param>
/// <param name="verifyFromContent">Should the file's content be examined to verify founded value.</param>
/// <returns>mime type of file, e.g.: "application/octet-stream"</returns>
public static string FindMime(string file, bool verifyFromContent)
{
string extension = Path.GetExtension(file);
string mimeType = string.Empty;
try
{
if (!String.IsNullOrEmpty(extension))
{
mimeType = ExtensionTypes.GetMimeType(extension);
}
if (verifyFromContent ||
(String.IsNullOrEmpty(mimeType) && File.Exists(file)))
{
mimeType = FindMimeByContent(file, mimeType);
}
}
catch { }
return((mimeType ?? string.Empty).Trim());//"application/octet-stream"
}
private IEnumerable <ExtensionTypes> DeserializeExtensions(Span <byte> buffer)
{
int currByte = 0;
List <ExtensionTypes> types = new List <ExtensionTypes>();
while (currByte < buffer.Length)
{
// Get the extension type value
ExtensionTypes type = (ExtensionTypes)buffer.Slice(currByte).ReadUShort();
currByte += 2;
types.Add(type);
// Get the length (in bytes) of this extension
ushort extensionLength = buffer.Slice(currByte).ReadUShort();
currByte += 2;
// We don't need the extension's info, so just skip the data.
currByte += extensionLength;
}
return(types);
}
public static byte GetLengthByExtensionType(ExtensionTypes extensionType)
{
byte extensionLength = 2;
switch (extensionType)
{
case ExtensionTypes.Mos:
extensionLength = 2;
break;
case ExtensionTypes.Mpan:
extensionLength = 19;
break;
case ExtensionTypes.MpanGrp:
extensionLength = 3;
break;
case ExtensionTypes.Span:
extensionLength = 18;
break;
}
return(extensionLength);
}
public static string FindExtension(string mimeType)
{
return(ExtensionTypes.GetExtension(mimeType));
}
private static void RemoveExtensionFromList(ref List <COMMAND_CLASS_SECURITY_2.SECURITY_2_MESSAGE_ENCAPSULATION.TVG1> list, ExtensionTypes extensionType)
{
for (int i = list.Count - 1; i >= 0; i--)
{
if (list[i].properties1.type == (byte)extensionType)
{
list.RemoveAt(i);
if (i > 0)
{
list[i - 1].properties1.moreToFollow = 0;
}
}
}
}
public void read(Reader reader, List <string> fileNames = null, int fileID = 0)
{
for (int y = 0; y < 16; y += 4)
{
fileName.hash[y + 3] = reader.ReadByte();
fileName.hash[y + 2] = reader.ReadByte();
fileName.hash[y + 1] = reader.ReadByte();
fileName.hash[y + 0] = reader.ReadByte();
}
fileName.usingHash = true;
var md5 = MD5.Create();
fileName.name = (fileID + 1) + ".bin"; //Make a base name
for (int i = 0; fileNames != null && i < fileNames.Count; i++)
{
// RSDKv4 Hashes all Strings at Lower Case
string fp = fileNames[i].ToLower();
bool match = true;
for (int z = 0; z < 16; z++)
{
if (calculateMD5Hash(fp)[z] != fileName.hash[z])
{
match = false;
break;
}
}
if (match)
{
fileName = new NameIdentifier(fileNames[i]);
break;
}
}
uint fileOffset = reader.ReadUInt32();
uint tmp = reader.ReadUInt32();
encrypted = (tmp & 0x80000000) != 0;
uint fileSize = (tmp & 0x7FFFFFFF);
long tmp2 = reader.BaseStream.Position;
reader.BaseStream.Position = fileOffset;
// Decrypt File if Encrypted
if (encrypted && !fileName.usingHash)
{
fileData = decrypt(reader.readBytes(fileSize), false);
}
else
{
fileData = reader.readBytes(fileSize);
}
reader.BaseStream.Position = tmp2;
extension = getExtensionFromData();
if (fileName.usingHash)
{
switch (extension)
{
case ExtensionTypes.GIF:
fileName.name = "Sprite" + (fileID + 1) + ".gif";
break;
case ExtensionTypes.MDL:
fileName.name = "Model" + (fileID + 1) + ".bin";
break;
case ExtensionTypes.OGG:
fileName.name = "Music" + (fileID + 1) + ".ogg";
break;
case ExtensionTypes.PNG:
fileName.name = "Image" + (fileID + 1) + ".png";
break;
case ExtensionTypes.WAV:
fileName.name = "SoundEffect" + (fileID + 1) + ".wav";
break;
case ExtensionTypes.UNKNOWN:
fileName.name = "UnknownFileType" + (fileID + 1) + ".bin";
break;
}
}
md5.Dispose();
}
private ExtensionTypes FindExtensionTypes(IEnumerable<Assembly> assemblies)
{
var result = new ExtensionTypes();
foreach (var type in assemblies.SelectMany(it => it.GetTypes()))
{
if (type.IsClass && !type.IsAbstract)
{
if (typeof(IPlugin).IsAssignableFrom(type))
{
result.PluginType = type;
}
if (typeof(INhMappingProvider).IsAssignableFrom(type))
{
result.NhMappingProviderType = type;
}
if (typeof(IPageLifecycleInterceptor).IsAssignableFrom(type))
{
result.PageLifecycleInterceptorTypes.Add(type);
}
}
}
return result;
}
public FileInfo(Reader reader, List <string> FileList, int cnt)
{
for (int y = 0; y < 16; y += 4)
{
md5Hash[y + 3] = reader.ReadByte();
md5Hash[y + 2] = reader.ReadByte();
md5Hash[y + 1] = reader.ReadByte();
md5Hash[y] = reader.ReadByte();
}
MD5FileName = ConvertByteArrayToString(md5Hash);
var md5 = MD5.Create();
FileName = (cnt + 1) + ".bin"; //Make a base name
for (int i = 0; i < FileList.Count; i++)
{
// Mania Hashes all Strings at Lower Case
string fp = FileList[i].ToLower();
bool match = true;
for (int z = 0; z < 16; z++)
{
if (CalculateMD5Hash(fp)[z] != md5Hash[z])
{
match = false;
break;
}
}
if (match)
{
FileName = FileList[i];
break;
}
}
DataOffset = reader.ReadUInt32();
uint tmp = reader.ReadUInt32();
Encrypted = (tmp & 0x80000000) != 0;
FileSize = (tmp & 0x7FFFFFFF);
long tmp2 = reader.BaseStream.Position;
reader.BaseStream.Position = DataOffset;
Filedata = reader.ReadBytes(FileSize);
// Decrypt File if Encrypted
if (Encrypted)
{
Filedata = Decrypt(Filedata);
}
reader.BaseStream.Position = tmp2;
Extension = GetExtensionFromData();
if (FileName == (cnt + 1) + ".bin")
{
switch (Extension)
{
case ExtensionTypes.GIF:
FileName = "Sprite" + (cnt + 1) + ".gif";
break;
case ExtensionTypes.R3D:
FileName = "Model" + (cnt + 1) + ".bin";
break;
case ExtensionTypes.OGG:
FileName = "Music" + (cnt + 1) + ".ogg";
break;
case ExtensionTypes.PNG:
FileName = "Image" + (cnt + 1) + ".png";
break;
case ExtensionTypes.WAV:
FileName = "SoundEffect" + (cnt + 1) + ".wav";
break;
case ExtensionTypes.UNKNOWN:
FileName = "UnknownFileType" + (cnt + 1) + ".bin";
break;
}
}
md5.Dispose();
}
void ResolveExtensions(XmlNode root)
{
foreach (XmlNode extension in root.ChildNodes)
{
if (extension is XmlComment)
{
continue;
}
string eName = extension.Attributes["name"].Value;
foreach (XmlNode r in extension.ChildNodes)
{
foreach (XmlNode node in r.ChildNodes)
{
if (r.Name == "require")
{
if (node.Name == "command")
{
if (ExtensionRequested(eName))
{
IncludedCommands.Add(node.Attributes["name"].Value);
ExtensionCommands.Add(node.Attributes["name"].Value);
}
}
else if (node.Name == "type")
{
string tName = node.Attributes["name"].Value;
if (ExtensionRequested(eName))
{
IncludedTypes.Add(tName);
}
ExtensionTypes.Add(tName);
}
else if (node.Name == "enum")
{
if (ExtensionRequested(eName))
{
var extends = node.Attributes["extends"];
var offsetNode = node.Attributes["offset"];
var extensionNumber = node.Attributes["extnumber"];
if (node.Attributes["alias"] != null)
{
continue;
}
if (extends != null && offsetNode != null)
{
var name = extends.Value;
int exNumber;
if (extensionNumber != null)
{
exNumber = int.Parse(extensionNumber.Value);
}
else
{
exNumber = 2;
}
var offset = int.Parse(offsetNode.Value);
var sign = 1;
if (node.Attributes["dir"] != null)
{
sign = -1;
}
EnumMap[name].Extend(node.Attributes["name"].Value, exNumber, offset, sign);
}
IncludedTypes.Add(node.Attributes["name"].Value);
}
}
}
}
}
}
}
