private List <ModuleConfig> FindModules(string path)
{
var configs = new List <ModuleConfig>();
foreach (string moduleFile in Directory.GetFiles(path, "*.module"))
{
ModuleConfig moduleConfig = IOUtility.jsonDeserializer.deserialize <ModuleConfig>(moduleFile);
if (moduleConfig != null)
{
moduleConfig.DirectoryPath = path;
moduleConfig.FilePath = moduleFile;
moduleConfig.Version_Internal = Parser.getUInt32FromIP(moduleConfig.Version);
for (var i = moduleConfig.Dependencies.Count - 1; i >= 0; i--)
{
ModuleDependency moduleDependency = moduleConfig.Dependencies[i];
if (moduleDependency.Name == "Framework" || moduleDependency.Name == "Unturned")
{
moduleConfig.Dependencies.RemoveAtFast(i);
}
else
{
moduleDependency.Version_Internal = Parser.getUInt32FromIP(moduleDependency.Version);
}
}
configs.Add(moduleConfig);
}
}
foreach (string subDirectory in Directory.GetDirectories(path))
{
configs.AddRange(FindModules(subDirectory));
}
return(configs);
}
protected virtual bool ReadModuleDependency(ICSharpCode.NRefactory.CSharp.Attribute attr, string name, ResolveResult resolveResult)
{
if ((name == (Translator.H5_ASSEMBLY + ".ModuleDependency")) ||
(resolveResult != null && resolveResult.Type != null && resolveResult.Type.FullName == (Translator.H5_ASSEMBLY + ".ModuleDependencyAttribute")))
{
if (attr.Arguments.Count > 0)
{
ModuleDependency dependency = new ModuleDependency();
object nameObj = GetAttributeArgumentValue(attr, resolveResult, 0);
if (nameObj is string)
{
dependency.DependencyName = nameObj.ToString();
}
nameObj = GetAttributeArgumentValue(attr, resolveResult, 1);
if (nameObj is string)
{
dependency.VariableName = nameObj.ToString();
}
else
{
dependency.VariableName = Module.EscapeName(dependency.DependencyName);
}
AssemblyInfo.Dependencies.Add(dependency);
}
return(true);
}
return(false);
}
public IEnumerable <ModuleDependency> GetDependencyModules(string directory, string assemblyPath)
{
_dependencies = new List <ModuleDependency>();
foreach (string file in _pathToAssembly)
{
AssemblyName asmName = null;
try
{
asmName = AssemblyName.GetAssemblyName(file);
}
catch (BadImageFormatException)
{
// nothing happens, return empty list
continue;
}
catch (Exception e)
{
throw new InvalidOperationException("Access to file is somewhat corrupted", e);
}
var dependency = new ModuleDependency
{
ModuleName = asmName.Name,
MinimalVersion = new Version(asmName.Version),
ProcessorArchitecture = asmName.ProcessorArchitecture,
HasLoadingOrderPriority = false,
};
_dependencies.Add(dependency);
}
return(_dependencies);
}
[Test] // #2312
public void CheckDependenciesShouldNotAddDuplicateModuleDependency_2312()
{
var emitter = EmitterHelper.GetEmitter();
emitter.DisableDependencyTracking = false;
var currentTypeInfo = Substitute.For <ITypeInfo>();
currentTypeInfo.Key = "Type1";
currentTypeInfo.Module = new Module("Module1");
var type = Substitute.For <BridgeType>("Type2");
var moduleName = "Module2";
var moduleType = ModuleType.ES6;
var module = new Module(moduleName, moduleType);
var moduleDependency = new ModuleDependency()
{
DependencyName = module.Name,
Type = module.Type,
PreventName = module.PreventModuleName
};
emitter.CurrentDependencies.Add(moduleDependency);
BridgeTypes.EnsureDependencies(type, emitter, currentTypeInfo, module);
Assert.AreEqual(1, emitter.CurrentDependencies.Count, "Did not add ModuleDependency");
var d = emitter.CurrentDependencies[0];
Assert.AreSame(moduleDependency, d, "ModuleDependency reference is the same");
Assert.AreEqual(moduleDependency.DependencyName, d.DependencyName, "Did not change Name");
Assert.AreEqual(moduleDependency.Type, d.Type, "Did not change Type");
}
public virtual void CheckModuleDependenies(TypeDefinition type, ITranslator translator)
{
if (type.HasCustomAttributes)
{
var attrName = Translator.H5_ASSEMBLY + ".ModuleDependencyAttribute";
var attrs = type.CustomAttributes.Where(attr => attr.AttributeType.FullName == attrName).ToList();
if (attrs.Count > 0)
{
foreach (var attr in attrs)
{
var typeInfo = EnsureTypeInfo(type, translator);
if (attr.ConstructorArguments.Count > 0)
{
ModuleDependency dependency = new ModuleDependency();
var obj = GetAttributeArgumentValue(attr, 0);
dependency.DependencyName = obj is string?obj.ToString() : "";
if (attr.ConstructorArguments.Count > 1)
{
obj = GetAttributeArgumentValue(attr, 1);
dependency.VariableName = obj is string?obj.ToString() : "";
}
else
{
dependency.VariableName = Module.EscapeName(dependency.DependencyName);
}
typeInfo.Dependencies.Add(dependency);
}
}
}
}
}
public ShellFeature(ModuleDependency dependency)
{
// dependency.Id to this.ModuleId is intended
// dependency.Id is the value deserialized from module.txt
ModuleId = dependency.Id;
Version = dependency.Version;
}
public void SetUp()
{
_logger = new Mock <ILogger>();
_testee = new ModuleDependency(_logger.Object);
_testee.IsEnabled = true;
_trigger = new Mock <ITrigger>();
_action = new Mock <IAction>();
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
base.ConfigureModuleCatalog(moduleCatalog);
moduleCatalog
.AddModule <UI.Module>("TTS.CardTool.UI.Module", dependsOn: ModuleDependency.GetDependencies <UI.Module>())
.AddModule <Converter.Module>("TTS.CardTool.Converter.Module", dependsOn: ModuleDependency.GetDependencies <Converter.Module>())
.AddModule <Processor.Module>("TTS.CardTool.Processor.Module", dependsOn: ModuleDependency.GetDependencies <Processor.Module>())
.AddModule <Processor.Options.Module>("TTS.CardTool.Processor.Options.Module", dependsOn: ModuleDependency.GetDependencies <Processor.Options.Module>());
}
public IEnumerable <ModuleDependency> GetDependencyModules(string directory,
string assemblyPath)
{
var dependencies = new List <ModuleDependency>();
// check for existence
if (!File.Exists(_depFileName))
{
//NOTE: if not find file then use empty list
return(dependencies);
}
// open file
using (StreamReader reader = File.OpenText(_depFileName))
{
string line;
while ((line = reader.ReadLine()) != null)
{
try
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, line);
AssemblyName asmName = AssemblyName.GetAssemblyName(path);
var dependency = new ModuleDependency
{
HasLoadingOrderPriority = false,
ModuleName = asmName.Name,
MinimalVersion = new Version(asmName.Version),
ProcessorArchitecture =
asmName.ProcessorArchitecture
};
dependencies.Add(dependency);
}
catch (Exception e)
{
throw new FileFormatException("File corrupted", e);
}
}
}
return(dependencies);
}
protected static IModulesDependenciesProvider GetModuleDependenciesOnSingleModule(string s, string versionString)
{
var moduleAonBDependency = new ModuleDependency()
{
HasLoadingOrderPriority = false,
MinimalVersion = new Version(versionString),
ModuleName = s,
ProcessorArchitecture = ProcessorArchitecture.MSIL
};
var moduleDependencyProviderMock = new Mock <IModulesDependenciesProvider>(MockBehavior.Loose);
moduleDependencyProviderMock
.Setup(x => x.GetDependencyModules(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new List <ModuleDependency>()
{
moduleAonBDependency
});
return(moduleDependencyProviderMock.Object);
}
private bool TryGetUnresolved(out ModuleDependency dependency)
{
if (_unresolved == null)
{
dependency = default;
return(false);
}
var modules = _unresolved.Keys;
if (!modules.Any())
{
dependency = default;
return(false);
}
var module = modules.First();
var sucess = _unresolved.TryGetValue(module, out var version);
Assert(sucess);
dependency = new ModuleDependency(module, version);
return(true);
}
public void TranslateDependantModuleInfo()
{
DependantModuleInfo dependantModuleInfo = new DependantModuleInfo("Module1", "Module1.dll", "Module1");
dependantModuleInfo.Dependencies = new ModuleDependency[1];
ModuleDependency dependency = new ModuleDependency();
dependency.Name = "ModuleDependency";
dependantModuleInfo.Dependencies[0] = dependency;
DependantModuleInfo[] modules = new DependantModuleInfo[1];
modules[0] = dependantModuleInfo;
GuidancePackageModuleInfo[] guidanceModules = new ModuleInfoMapper().Translate(modules);
Assert.AreEqual(guidanceModules.Length, modules.Length);
Assert.AreEqual(guidanceModules[0].Name, dependantModuleInfo.Name);
Assert.AreEqual(guidanceModules[0].AssemblyName, dependantModuleInfo.AssemblyName);
Assert.AreEqual(guidanceModules[0].VirtualPath, dependantModuleInfo.VirtualPath);
Assert.AreEqual(guidanceModules[0].Dependencies.Length, dependantModuleInfo.Dependencies.Length);
Assert.AreEqual(guidanceModules[0].Dependencies[0].Name, dependantModuleInfo.Dependencies[0].Name);
}
public static bool Prefix(CSteamID steamID, byte[] packet, int offset)
{
var steamPacket = (ESteamPacket)packet[offset];
if (steamPacket == ESteamPacket.CONNECT)
{
for (int l = 0; l < Provider.pending.Count; l++)
{
if (Provider.pending[l].playerID.steamID == steamID)
{
Provider.reject(steamID, ESteamRejection.ALREADY_PENDING);
return(false);
}
}
for (int m = 0; m < Provider.clients.Count; m++)
{
if (Provider.clients[m].playerID.steamID == steamID)
{
Provider.reject(steamID, ESteamRejection.ALREADY_CONNECTED);
return(false);
}
}
object[] objects = SteamPacker.getObjects(steamID, offset, 0, packet, new Type[]
{
Types.BYTE_TYPE,
Types.BYTE_TYPE,
Types.STRING_TYPE,
Types.STRING_TYPE,
Types.BYTE_ARRAY_TYPE,
Types.BYTE_ARRAY_TYPE,
Types.BYTE_ARRAY_TYPE,
Types.BYTE_TYPE,
Types.UINT32_TYPE,
Types.BOOLEAN_TYPE,
Types.SINGLE_TYPE,
Types.STRING_TYPE,
Types.STEAM_ID_TYPE,
Types.BYTE_TYPE,
Types.BYTE_TYPE,
Types.BYTE_TYPE,
Types.COLOR_TYPE,
Types.COLOR_TYPE,
Types.COLOR_TYPE,
Types.BOOLEAN_TYPE,
Types.UINT64_TYPE,
Types.UINT64_TYPE,
Types.UINT64_TYPE,
Types.UINT64_TYPE,
Types.UINT64_TYPE,
Types.UINT64_TYPE,
Types.UINT64_TYPE,
Types.UINT64_ARRAY_TYPE,
Types.BYTE_TYPE,
Types.STRING_TYPE,
Types.STRING_TYPE,
Types.STEAM_ID_TYPE,
Types.UINT32_TYPE,
Types.BYTE_ARRAY_TYPE
});
byte[] array3 = (byte[])objects[33];
if (array3.Length != 20)
{
Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
return(false);
}
byte newCharacterID = (byte)objects[1];
if (!Provider.modeConfigData.Players.Allow_Per_Character_Saves)
{
newCharacterID = 0;
}
SteamPlayerID steamPlayerID = new SteamPlayerID(steamID, newCharacterID, (string)objects[2], (string)objects[3], (string)objects[11], (CSteamID)objects[12], array3);
if ((uint)objects[8] != Provider.APP_VERSION_PACKED)
{
Provider.reject(steamID, ESteamRejection.WRONG_VERSION, Provider.APP_VERSION);
return(false);
}
if ((uint)objects[32] != Level.packedVersion)
{
Provider.reject(steamID, ESteamRejection.WRONG_LEVEL_VERSION, Level.version);
return(false);
}
if (steamPlayerID.playerName.Length < 2)
{
Provider.reject(steamID, ESteamRejection.NAME_PLAYER_SHORT);
return(false);
}
if (steamPlayerID.characterName.Length < 2)
{
Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_SHORT);
return(false);
}
if (steamPlayerID.playerName.Length > 32)
{
Provider.reject(steamID, ESteamRejection.NAME_PLAYER_LONG);
return(false);
}
if (steamPlayerID.characterName.Length > 32)
{
Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_LONG);
return(false);
}
if (long.TryParse(steamPlayerID.playerName, NumberStyles.Any, CultureInfo.InvariantCulture, out _) || double.TryParse(steamPlayerID.playerName, NumberStyles.Any, CultureInfo.InvariantCulture, out _))
{
Provider.reject(steamID, ESteamRejection.NAME_PLAYER_NUMBER);
return(false);
}
if (long.TryParse(steamPlayerID.characterName, NumberStyles.Any, CultureInfo.InvariantCulture, out _) || double.TryParse(steamPlayerID.characterName, NumberStyles.Any, CultureInfo.InvariantCulture, out _))
{
Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_NUMBER);
return(false);
}
if (Provider.filterName)
{
if (!NameTool.isValid(steamPlayerID.playerName))
{
Provider.reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return(false);
}
if (!NameTool.isValid(steamPlayerID.characterName))
{
Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return(false);
}
}
if (NameTool.containsRichText(steamPlayerID.playerName))
{
Provider.reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return(false);
}
if (NameTool.containsRichText(steamPlayerID.characterName))
{
Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return(false);
}
uint remoteIP;
if (SteamGameServerNetworking.GetP2PSessionState(steamID, out P2PSessionState_t p2PSessionState_t))
{
remoteIP = p2PSessionState_t.m_nRemoteIP;
}
else
{
remoteIP = 0U;
}
Utils.checkBanStatus(steamPlayerID, remoteIP, out bool flag3, out string object_, out uint num5);
if (flag3)
{
byte[] bytes3 = SteamPacker.getBytes(0, out int size4, 9, object_, num5);
Provider.send(steamID, ESteamPacket.BANNED, bytes3, size4, 0);
return(false);
}
bool flag4 = SteamWhitelist.checkWhitelisted(steamID);
if (Provider.isWhitelisted && !flag4)
{
Provider.reject(steamID, ESteamRejection.WHITELISTED);
return(false);
}
if (Provider.clients.Count - Dummy.Instance.Dummies.Count + 1 > Provider.maxPlayers && Provider.pending.Count + 1 > Provider.queueSize)
{
Provider.reject(steamID, ESteamRejection.SERVER_FULL);
return(false);
}
byte[] array4 = (byte[])objects[4];
if (array4.Length != 20)
{
Provider.reject(steamID, ESteamRejection.WRONG_PASSWORD);
return(false);
}
byte[] array5 = (byte[])objects[5];
if (array5.Length != 20)
{
Provider.reject(steamID, ESteamRejection.WRONG_HASH_LEVEL);
return(false);
}
byte[] array6 = (byte[])objects[6];
if (array6.Length != 20)
{
Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
return(false);
}
string text = (string)objects[29];
ModuleDependency[] array7;
if (string.IsNullOrEmpty(text))
{
array7 = Array.Empty <ModuleDependency>();
}
else
{
string[] array8 = text.Split(new char[]
{
';'
});
array7 = new ModuleDependency[array8.Length];
for (int n = 0; n < array7.Length; n++)
{
string[] array9 = array8[n].Split(new char[]
{
','
});
if (array9.Length == 2)
{
array7[n] = new ModuleDependency
{
Name = array9[0]
};
uint.TryParse(array9[1], NumberStyles.Any, CultureInfo.InvariantCulture, out array7[n].Version_Internal);
}
}
}
var moduleList = new List <Module>();
ModuleHook.getRequiredModules(moduleList);
bool flag5 = true;
for (int num6 = 0; num6 < array7.Length; num6++)
{
bool flag6 = false;
if (array7[num6] != null)
{
for (int num7 = 0; num7 < moduleList.Count; num7++)
{
if (moduleList[num7]?.config != null && moduleList[num7].config.Name == array7[num6].Name && moduleList[num7].config.Version_Internal >= array7[num6].Version_Internal)
{
flag6 = true;
break;
}
}
}
if (!flag6)
{
flag5 = false;
break;
}
}
if (!flag5)
{
Provider.reject(steamID, ESteamRejection.CLIENT_MODULE_DESYNC);
return(false);
}
bool flag7 = true;
for (int num8 = 0; num8 < moduleList.Count; num8++)
{
bool flag8 = false;
if (moduleList[num8]?.config != null)
{
for (int num9 = 0; num9 < array7.Length; num9++)
{
if (array7[num9] != null && array7[num9].Name == moduleList[num8].config.Name && array7[num9].Version_Internal >= moduleList[num8].config.Version_Internal)
{
flag8 = true;
break;
}
}
}
if (!flag8)
{
flag7 = false;
break;
}
}
if (!flag7)
{
Provider.reject(steamID, ESteamRejection.SERVER_MODULE_DESYNC);
return(false);
}
if (!string.IsNullOrEmpty(Provider.serverPassword) && !Hash.verifyHash(array4, Provider.serverPasswordHash))
{
Provider.reject(steamID, ESteamRejection.WRONG_PASSWORD);
return(false);
}
if (!Hash.verifyHash(array5, Level.hash))
{
Provider.reject(steamID, ESteamRejection.WRONG_HASH_LEVEL);
return(false);
}
if (!ReadWrite.appIn(array6, (byte)objects[7]))
{
Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
return(false);
}
if ((float)objects[10] >= Provider.configData.Server.Max_Ping_Milliseconds / 1000f)
{
Provider.reject(steamID, ESteamRejection.PING);
return(false);
}
Utils.notifyClientPending(steamID);
SteamPending item = new SteamPending(steamPlayerID, (bool)objects[9], (byte)objects[13], (byte)objects[14], (byte)objects[15], (Color)objects[16], (Color)objects[17], (Color)objects[18], (bool)objects[19], (ulong)objects[20], (ulong)objects[21], (ulong)objects[22], (ulong)objects[23], (ulong)objects[24], (ulong)objects[25], (ulong)objects[26], (ulong[])objects[27], (EPlayerSkillset)((byte)objects[28]), (string)objects[30], (CSteamID)objects[31]);
if (Provider.isWhitelisted || !flag4)
{
Provider.pending.Add(item);
if (Provider.pending.Count == 1)
{
Utils.verifyNextPlayerInQueue();
}
return(false);
}
if (Provider.pending.Count == 0)
{
Provider.pending.Add(item);
Utils.verifyNextPlayerInQueue();
return(false);
}
Provider.pending.Insert(1, item);
return(false);
}
return(true);
}
public ModuleDependencies(ModuleDependency Type, string Value)
{
//Intentially left empty
}
public async ValueTask <IEnumerable <ModuleReleaseIdentifier> > GetMatchingReleasesAsync(ModuleDependency dependency, CancellationToken cancellation)
{
var module = await _storageEngine.GetByIdAsync(typeof(Module), dependency.Module.ToString(), cancellation) as Module;
if (module == null)
{
return(Enumerable.Empty <ModuleReleaseIdentifier>()); // TODO: Is this correct?
}
return(module.GetMatchingReleases(dependency.VersionRange).Select(p => p.Id));
}
private async Task <IEnumerable <ResolvedInstallationSet> > TryResolveSingleDependencyAsync(ModuleDependency dependency,
IDependencyResolver dependencyResolver,
CancellationToken cancellation)
{
// We have a resolved dependency that does not match our version filter => This is a version conflict
if (_resolved != null &&
_resolved.TryGetValue(dependency.Module, out var resolvedDependency) &&
!dependency.VersionRange.IsMatch(resolvedDependency))
{
return(Enumerable.Empty <ResolvedInstallationSet>());
}
var matchingReleases = await dependencyResolver.GetMatchingReleasesAsync(dependency, cancellation);
var resolvedInstallationSets = new List <ResolvedInstallationSet>();
var resolveTasks = new List <Task <IEnumerable <ResolvedInstallationSet> > >();
foreach (var matchingRelease in matchingReleases)
{
var dependencies = await dependencyResolver.GetDependenciesAsync(matchingRelease, cancellation);
if (!TryCombine(matchingRelease, dependencies, out var unresolved))
{
continue;
}
var resolved = (_resolved ?? ImmutableDictionary <ModuleIdentifier, ModuleVersion> .Empty).Add(matchingRelease.Module, matchingRelease.Version);
// If there are no unresolved dependencies for the release, we can short circuit.
if (unresolved.Count == 0)
{
resolvedInstallationSets.Add(new ResolvedInstallationSet(resolved.Select(p => new ModuleReleaseIdentifier(p.Key, p.Value))));
}
else
{
var unresolvedInstallationSet = new UnresolvedInstallationSet(resolved, unresolved);
resolveTasks.Add(unresolvedInstallationSet.ResolveAsync(dependencyResolver, cancellation));
}
}
// TODO: Is it possible that there are duplicates?
return((await Task.WhenAll(resolveTasks)).SelectMany(_ => _).Concat(resolvedInstallationSets));
}
public static bool Prefix(CSteamID steamID, byte[] packet, int offset, int size, int channel)
{
if (!Dedicator.isDedicated)
{
return(true);
}
byte index1 = packet[offset];
if (!(index1 < (byte)26))
{
UnityEngine.Debug.LogWarning((object)("Received invalid packet index from " + (object)steamID + ", so we're refusing them"));
SDG.Unturned.Provider.refuseGarbageConnection(steamID, "sv invalid packet index");
}
else
{
ESteamPacket packet1 = (ESteamPacket)index1;
if (packet1 == ESteamPacket.AUTHENTICATE || packet1 == ESteamPacket.CONNECT)
{
Console.WriteLine(packet1);
}
if (packet1 == ESteamPacket.CONNECT)
{
RocketPlayer player = new RocketPlayer(steamID.ToString());
bool result = player.HasPermission("QueueBypasser.Skip");
Console.WriteLine(result);
if (!result)
{
return(true); //We don't need to do jack shit because he doesn't have the right permission.
}
for (int index2 = 0; index2 < SDG.Unturned.Provider.pending.Count; ++index2)
{
if (SDG.Unturned.Provider.pending[index2].playerID.steamID == steamID)
{
Console.WriteLine("line 1");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.ALREADY_PENDING);
return(true);
}
}
for (int index2 = 0; index2 < SDG.Unturned.Provider.clients.Count; ++index2)
{
if (SDG.Unturned.Provider.clients[index2].playerID.steamID == steamID)
{
Console.WriteLine("line 2");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.ALREADY_CONNECTED);
return(true);
}
}
object[] objects = SteamPacker.getObjects(steamID, offset, 0, packet, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.STRING_TYPE, Types.STRING_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_ARRAY_TYPE, Types.BYTE_TYPE, Types.UINT32_TYPE, Types.BOOLEAN_TYPE, Types.SINGLE_TYPE, Types.STRING_TYPE, Types.STEAM_ID_TYPE, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.BYTE_TYPE, Types.COLOR_TYPE, Types.COLOR_TYPE, Types.COLOR_TYPE, Types.BOOLEAN_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_TYPE, Types.UINT64_ARRAY_TYPE, Types.BYTE_TYPE, Types.STRING_TYPE, Types.STRING_TYPE, Types.STEAM_ID_TYPE, Types.UINT32_TYPE);
SteamPlayerID newPlayerID = new SteamPlayerID(steamID, (byte)objects[1], (string)objects[2], (string)objects[3], (string)objects[11], (CSteamID)objects[12]);
if (objects[8].ToString() != SDG.Unturned.Provider.APP_VERSION && (int)(uint)objects[8] != Parser.getUInt32FromIP(SDG.Unturned.Provider.APP_VERSION))
{
Console.WriteLine("line 3");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_VERSION);
return(true);
}
if (newPlayerID.playerName.Length < 2)
{
Console.WriteLine("line 4");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_SHORT);
return(true);
}
if (newPlayerID.characterName.Length < 2)
{
Console.WriteLine("line 5");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_SHORT);
return(true);
}
if (newPlayerID.playerName.Length > 32)
{
Console.WriteLine("line 6");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_LONG);
return(true);
}
if (newPlayerID.characterName.Length > 32)
{
Console.WriteLine("line 7");
//Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_LONG);
return(true);
}
long result1;
double result2;
if (long.TryParse(newPlayerID.playerName, out result1) || double.TryParse(newPlayerID.playerName, out result2))
{
Console.WriteLine("line 8");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_NUMBER);
return(true);
}
long result3;
double result4;
if (long.TryParse(newPlayerID.characterName, out result3) || double.TryParse(newPlayerID.characterName, out result4))
{
Console.WriteLine("line 9");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_NUMBER);
return(true);
}
if (SDG.Unturned.Provider.filterName)
{
if (!NameTool.isValid(newPlayerID.playerName))
{
Console.WriteLine("line 10");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return(true);
}
if (!NameTool.isValid(newPlayerID.characterName))
{
Console.WriteLine("line 11");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return(true);
}
}
if (NameTool.containsRichText(newPlayerID.playerName))
{
Console.WriteLine("line 12");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_PLAYER_INVALID);
return(true);
}
if (NameTool.containsRichText(newPlayerID.characterName))
{
Console.WriteLine("line 13");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.NAME_CHARACTER_INVALID);
return(true);
}
P2PSessionState_t pConnectionState;
uint ip = !SteamGameServerNetworking.GetP2PSessionState(steamID, out pConnectionState) ? 0U : pConnectionState.m_nRemoteIP;
SteamBlacklistID blacklistID;
if (SteamBlacklist.checkBanned(steamID, ip, out blacklistID))
{
//int size1;
//byte[] bytes = SteamPacker.getBytes(0, out size1, (object)(byte)9, (object)blacklistID.reason, (object)blacklistID.getTime());
//SDG.Unturned.Provider.send(steamID, ESteamPacket.BANNED, bytes, size1, 0);
Console.WriteLine("line 15");
return(true);
}
bool flag3 = SteamWhitelist.checkWhitelisted(steamID);
if (SDG.Unturned.Provider.isWhitelisted && !flag3)
{
Console.WriteLine("line 16");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WHITELISTED);
return(true);
}
byte[] hash_0_1 = (byte[])objects[4];
if (hash_0_1.Length != 20)
{
Console.WriteLine("line 17");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_PASSWORD);
return(true);
}
byte[] hash_0_2 = (byte[])objects[5];
if (hash_0_2.Length != 20)
{
Console.WriteLine("line 18");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_LEVEL);
return(true);
}
byte[] h = (byte[])objects[6];
if (h.Length != 20)
{
Console.WriteLine("line 19");
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
return(true);
}
string str1 = (string)objects[29];
ModuleDependency[] moduleDependencyArray;
if (string.IsNullOrEmpty(str1))
{
moduleDependencyArray = new ModuleDependency[0];
}
else
{
string[] strArray1 = str1.Split(';');
moduleDependencyArray = new ModuleDependency[strArray1.Length];
for (int index2 = 0; index2 < moduleDependencyArray.Length; ++index2)
{
string[] strArray2 = strArray1[index2].Split(',');
if (strArray2.Length == 2)
{
moduleDependencyArray[index2] = new ModuleDependency();
moduleDependencyArray[index2].Name = strArray2[0];
uint.TryParse(strArray2[1], out moduleDependencyArray[index2].Version_Internal);
}
}
}
critMods.Clear();
ModuleHook.getRequiredModules(critMods);
bool flag4 = true;
for (int index2 = 0; index2 < moduleDependencyArray.Length; ++index2)
{
bool flag2 = false;
if (moduleDependencyArray[index2] != null)
{
for (int index3 = 0; index3 < critMods.Count; ++index3)
{
if (critMods[index3] != null && critMods[index3].config != null && (critMods[index3].config.Name == moduleDependencyArray[index2].Name && critMods[index3].config.Version_Internal >= moduleDependencyArray[index2].Version_Internal))
{
flag2 = true;
return(true);
}
}
}
if (!flag2)
{
flag4 = false;
return(true);
}
}
if (!flag4)
{
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.CLIENT_MODULE_DESYNC);
Console.WriteLine("line 20");
return(true);
}
bool flag5 = true;
for (int index2 = 0; index2 < critMods.Count; ++index2)
{
bool flag2 = false;
if (critMods[index2] != null && critMods[index2].config != null)
{
for (int index3 = 0; index3 < moduleDependencyArray.Length; ++index3)
{
if (moduleDependencyArray[index3] != null && moduleDependencyArray[index3].Name == critMods[index2].config.Name && moduleDependencyArray[index3].Version_Internal >= critMods[index2].config.Version_Internal)
{
flag2 = true;
return(true);
}
}
}
if (!flag2)
{
flag5 = false;
return(true);
}
}
if (!flag5)
{
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.SERVER_MODULE_DESYNC);
Console.WriteLine("line 21");
return(true);
}
Console.WriteLine("section 1");
if (SDG.Unturned.Provider.serverPassword == string.Empty || Hash.verifyHash(hash_0_1, _serverPasswordHash))
{
Console.WriteLine("section 2");
if (Hash.verifyHash(hash_0_2, Level.hash))
{
Console.WriteLine("section 3");
if (ReadWrite.appIn(h, (byte)objects[7]))
{
Console.WriteLine("section 4");
if ((double)(float)objects[10] < (double)SDG.Unturned.Provider.configData.Server.Max_Ping_Milliseconds / 1000.0)
{
Console.WriteLine("section 5");
//var pending = new SteamPending(newPlayerID, (bool)objects[9], (byte)objects[13], (byte)objects[14], (byte)objects[15], (Color)objects[16], (Color)objects[17], (Color)objects[18], (bool)objects[19], (ulong)objects[20], (ulong)objects[21], (ulong)objects[22], (ulong)objects[23], (ulong)objects[24], (ulong)objects[25], (ulong)objects[26], (ulong[])objects[27], (EPlayerSkillset)(byte)objects[28], (string)objects[30], (CSteamID)objects[31]);
//Provider.pending.Insert(0, pending);
//pending.sendVerifyPacket();
//Console.WriteLine($"Accepting {pending.playerID.steamID}.");
return(false);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.PING);
Console.WriteLine("line 22");
return(true);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_ASSEMBLY);
Console.WriteLine("line 23");
return(true);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_HASH_LEVEL);
Console.WriteLine("line 24");
return(true);
}
//SDG.Unturned.Provider.reject(steamID, ESteamRejection.WRONG_PASSWORD);
Console.WriteLine("line 25");
return(true);
}
}
return(true);
}
public ModuleDependencies(ModuleDependency Type, string Value)
{
//Intentially left empty
}
private void CreateDependencies()
{
foreach (ModuleConfig moduleConfig in _configSection.Modules)
{
var module = GetModuleByName(moduleConfig.Name);
if (module == null)
{
continue;
}
foreach (ModuleDependencyConfig dependencyConfig in moduleConfig.Dependencies)
{
var logger = _container.First().GetExportedValue <ILogger>();
logger.Init(module.GetType() + "-Dependency");
var dependency = new ModuleDependency(logger);
// given
foreach (ConditionConfigBase conditionConfig in dependencyConfig.Conditions)
{
var propertyEqualConditionConfig = conditionConfig as PropertyEqualsConditionConfig;
if (propertyEqualConditionConfig != null)
{
dependency.AddCondition(new PropertyEqualityCondition(
module,
propertyEqualConditionConfig.PropertyName,
propertyEqualConditionConfig.EqualsValue));
continue;
}
}
// when
foreach (TriggerConfigBase triggerConfig in dependencyConfig.Triggers)
{
var eventTriggerConfig = triggerConfig as EventTriggerConfig;
if (eventTriggerConfig != null)
{
dependency.AddTrigger(new EventTrigger(GetModuleByName(eventTriggerConfig.Path), eventTriggerConfig.EventName));
continue;
}
var eventNotRaisedTriggerConfig = triggerConfig as EventNotRaisedTriggerConfig;
if (eventNotRaisedTriggerConfig != null)
{
dependency.AddTrigger(new EventNotRaisedTrigger(
GetModuleByName(eventNotRaisedTriggerConfig.Path),
eventNotRaisedTriggerConfig.EventName,
TimeSpan.FromMilliseconds(eventNotRaisedTriggerConfig.Timeout)));
continue;
}
var propertyChangedTriggerConfig = triggerConfig as PropertyChangedTriggerConfig;
if (propertyChangedTriggerConfig != null)
{
dependency.AddTrigger(new PropertyChangedTrigger(
GetModuleByName(propertyChangedTriggerConfig.Path),
propertyChangedTriggerConfig.PropertyName));
continue;
}
var propertyNotChangedTriggerConfig = triggerConfig as PropertyNotChangedTriggerConfig;
if (propertyNotChangedTriggerConfig != null)
{
dependency.AddTrigger(new PropertyNotChangedTrigger(
GetModuleByName(propertyNotChangedTriggerConfig.Path),
propertyNotChangedTriggerConfig.PropertyName,
TimeSpan.FromMilliseconds(propertyNotChangedTriggerConfig.Timeout)));
continue;
}
var periodicTimeTriggerConfig = triggerConfig as PeriodicTimeTriggerConfig;
if (periodicTimeTriggerConfig != null)
{
dependency.AddTrigger(new PeriodicTimeTrigger(TimeSpan.FromMilliseconds(periodicTimeTriggerConfig.Timeout)));
continue;
}
}
// then
foreach (var actionConfig in dependencyConfig.Actions)
{
var invokeMethodActionConfig = actionConfig as InvokeMethodActionConfig;
if (invokeMethodActionConfig != null)
{
dependency.AddAction(new InvokeMethodAction(module, invokeMethodActionConfig.MethodName));
continue;
}
}
_dependencyManager.Add(dependency);
_logger.Debug("added module dependency to " + module);
}
}
}
