themaster1970sf/TShock
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Merge remote-tracking branch 'upstream/general-devel' into regions

Browse source
This commit is contained in:
Ivan 2018-04-29 18:39:12 +02:00
commit 44dfc570ab
9 changed files with 20 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -51,6 +51,7 @@ Thumbs.db
*.csproj.user
*/_ReSharper*/*
*.user
.vs/*
#Template Bat file#
###################

3
CHANGELOG.md
View file

@ -80,6 +80,9 @@ This is the rolling changelog for TShock for Terraria. Use past tense when addin
* `Utils.MaxChests()` is now `Utils.HasWorldReachedMaxChests()`. (@hakusaro)
* `Utils.GetIPv4Address()` is now `Utils.GetIPv4AddressFromHostname()`. (@hakusaro)
* Fixed the disappearing problem when placing tile entities. (@mistzzt)
* Removed the stat tracking system. (@hakusaro)
* Fixed erroneous kicks and bans when using `KickOnMediumcoreDeath` and `BanOnMediumcoreDeath` options. (@DankRank)
* Removed `TSPlayer.InitSpawn` field. (@DankRank)
## TShock 4.3.25
* Fixed a critical exploit in the Terraria protocol that could cause massive unpreventable world corruption as well as a number of other problems. Thanks to @bartico6 for reporting. Fixed by the efforts of @QuiCM, @hakusaro, and tips in the right directioon from @bartico6.

4
README.md
View file

@ -122,7 +122,7 @@ You need to re-run the patcher any time `OTAPI` updates. You need to rebuild `Te
##### TShock
1. Open the `TShockAPI.sln` solution in the root of the repository.
1. Open the `TShock.sln` solution in the root of the repository.
1. Build the solution. It should correctly download NuGet packages automatically and build against the aforementioned `TerrariaServerAPI` project you just built.
@ -219,4 +219,4 @@ Need help? Join us on [#tshock-programming in Discord](https://discord.gg/ABtrBa
> By participating in the TShock for Terraria community, all members will adhere to maintaining decorum with respect to all humans, in and out of the community. Members will not engage in discussion that inappropriately disparages or marginalizes any group of people or any individual. Members will not attempt to further or advance an agenda to the point of being overbearing or close minded (such as through spreading FUD). Members will not abuse services provided to them and will follow the guidance of community leaders on a situational basis about what abuse consists of. Members will adhere to United States and international law. If members notice a violation of this code of conduct, they will not engage but will instead contact the leadership team on either the forums or Discord.
> Do not attempt to circumvent or bypass the code of conduct by using clever logic or reasoning (e.g., insulting Facepunch members, because they weren't directly mentioned here).
> Do not attempt to circumvent or bypass the code of conduct by using clever logic or reasoning (e.g., insulting Facepunch members, because they weren't directly mentioned here).

41
TShockAPI/GetDataHandlers.cs
View file

@ -2380,16 +2380,21 @@ namespace TShockAPI
}
}
if (args.TPlayer.difficulty == 2 && (TShock.Config.KickOnHardcoreDeath || TShock.Config.BanOnHardcoreDeath))
// Handle kicks/bans on mediumcore/hardcore deaths.
if (args.TPlayer.difficulty != 0) // Player is not softcore
{
if (TShock.Config.BanOnHardcoreDeath)
{
if (!args.Player.Ban(TShock.Config.HardcoreBanReason, false, "hardcore-death"))
bool mediumcore = args.TPlayer.difficulty == 1;
bool shouldBan = mediumcore ? TShock.Config.BanOnMediumcoreDeath : TShock.Config.BanOnHardcoreDeath;
bool shouldKick = mediumcore ? TShock.Config.KickOnMediumcoreDeath : TShock.Config.KickOnHardcoreDeath;
string banReason = mediumcore ? TShock.Config.MediumcoreBanReason : TShock.Config.HardcoreBanReason;
string kickReason = mediumcore ? TShock.Config.MediumcoreKickReason : TShock.Config.HardcoreKickReason;
if(shouldBan) {
if (!args.Player.Ban(banReason, false, "TShock"))
args.Player.Kick("You died! Normally, you'd be banned.", true, true);
}
else
{
args.Player.Kick(TShock.Config.HardcoreKickReason, true, true, null, false);
else if(shouldKick) {
args.Player.Kick(kickReason, true, true, null, false);
}
}
@ -2440,28 +2445,6 @@ namespace TShockAPI
if (OnPlayerSpawn(args.Player, args.Data, player, spawnx, spawny))
return true;
if (args.Player.InitSpawn && args.TPlayer.inventory[args.TPlayer.selectedItem].type != 50)
{
if (args.TPlayer.difficulty == 1 && (TShock.Config.KickOnMediumcoreDeath || TShock.Config.BanOnMediumcoreDeath))
{
if (args.TPlayer.selectedItem != 50)
{
if (TShock.Config.BanOnMediumcoreDeath)
{
if (!args.Player.Ban(TShock.Config.MediumcoreBanReason, false, "mediumcore-death"))
args.Player.Kick("You died! Normally, you'd be banned.", true, true);
}
else
{
args.Player.Kick(TShock.Config.MediumcoreKickReason, true, true, null, false);
}
return true;
}
}
}
else
args.Player.InitSpawn = true;
if ((Main.ServerSideCharacter) && (args.Player.sX > 0) && (args.Player.sY > 0) && (args.TPlayer.SpawnX > 0) && ((args.TPlayer.SpawnX != args.Player.sX) && (args.TPlayer.SpawnY != args.Player.sY)))
{

314
TShockAPI/StatTracker.cs
View file

@ -1,314 +0,0 @@
/*
TShock, a server mod for Terraria
Copyright (C) 2011-2018 Pryaxis & TShock Contributors
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
using System;
using System.Net;
using System.Threading;
using System.Web;
using TerrariaApi.Server;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Net.Http;
using System.Threading.Tasks;
using TShockAPI.Extensions;
using System.IO;
using System.Text.RegularExpressions;
namespace TShockAPI
{
/// <summary>
/// StatTracker class for tracking various server metrics
/// </summary>
public class StatTracker
{
/// <summary>
/// Calls the GetPhysicallyInstalledSystemMemory Windows API function, returning the amount of RAM installed on the host PC
/// </summary>
/// <param name="totalMemInKb">The amount of memory (in kilobytes) present on the host PC</param>
/// <returns></returns>
[DllImport("kernel32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetPhysicallyInstalledSystemMemory(out long totalMemInKb);
/// <summary>
/// A provider token set on the command line. Used by the stats server to group providers
/// </summary>
public string ProviderToken = "";
/// <summary>
/// Whether or not to opt out of stat tracking
/// </summary>
public bool OptOut = false;
private PluginItem[] plugins;
private long totalMem = 0;
private string serverId = "";
private HttpClient _client;
private const string TrackerUrl = "http://stats.tshock.co/submit/{0}";
/// <summary>
/// Creates a new instance of <see cref="StatTracker"/>
/// </summary>
public StatTracker()
{
}
/// <summary>
/// Starts the stat tracker
/// </summary>
public void Start()
{
if (OptOut)
{
//If opting out, return and do not start stat tracking
return;
}
//HttpClient with a 5 second timeout
_client = new HttpClient()
{
Timeout = new TimeSpan(0, 0, 5)
};
serverId = Guid.NewGuid().ToString();
Thread t = new Thread(async () =>
{
do
{
//Wait 5 minutes
await Task.Delay(1000 * 60 * 5);
//Then update again
await SendUpdateAsync();
} while (true);
})
{
Name = "TShock Stat Tracker Thread",
IsBackground = true
};
t.Start();
}
private async Task SendUpdateAsync()
{
JsonData data = PrepareJsonData();
var serialized = Newtonsoft.Json.JsonConvert.SerializeObject(data);
var encoded = HttpUtility.UrlEncode(serialized);
var uri = string.Format(TrackerUrl, encoded);
try
{
HttpResponseMessage msg = await _client.GetAsync(uri);
if (msg.StatusCode != HttpStatusCode.OK)
{
string reason = msg.ReasonPhrase;
if (string.IsNullOrWhiteSpace(reason))
{
reason = "none";
}
throw new WebException("Stats server did not respond with an OK. "
+ $"Server message: [error {msg.StatusCode}] {reason}");
}
}
catch (Exception ex)
{
string msg = ex.BuildExceptionString();
//Give the console a brief
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"StatTracker warning: {msg}");
Console.ForegroundColor = ConsoleColor.Gray;
//And log the full exception
TShock.Log.Warn($"StatTracker warning: {ex.ToString()}");
TShock.Log.ConsoleError("Retrying in 5 minutes.");
}
}
private JsonData PrepareJsonData()
{
return new JsonData()
{
port = Terraria.Netplay.ListenPort,
currentPlayers = TShock.Utils.GetActivePlayerCount(),
maxPlayers = TShock.Config.MaxSlots,
systemRam = GetTotalSystemRam(ServerApi.RunningMono),
version = TShock.VersionNum.ToString(),
terrariaVersion = Terraria.Main.versionNumber2,
providerId = ProviderToken,
serverId = serverId,
mono = ServerApi.RunningMono,
ignorePluginVersion = ServerApi.IgnoreVersion,
loadedPlugins = GetLoadedPlugins()
};
}
private PluginItem[] GetLoadedPlugins()
{
if (plugins != null)
{
return plugins; //Return early
}
plugins = new PluginItem[ServerApi.Plugins.Count]; //Initialize with enough room to store the ammount of plugins loaded.
for (var i = 0; i < ServerApi.Plugins.Count; i++)
{
var pluginItem = new PluginItem();
var apiAttribute = (ApiVersionAttribute)ServerApi.Plugins[i].Plugin.GetType().GetCustomAttributes(typeof(ApiVersionAttribute), false).FirstOrDefault();
//The current implementation of loading plugins doesn't allow for a plugin to be loaded without an ApiVersion, the UNKNOWN is there incase a change is made to allow it
pluginItem.apiVersion = apiAttribute?.ApiVersion.ToString() ?? "UNKNOWN";
pluginItem.name = ServerApi.Plugins[i].Plugin.Name;
pluginItem.version = ServerApi.Plugins[i].Plugin.Version.ToString();
plugins[i] = pluginItem;
}
return plugins;
}
/// <summary>
/// Returns the amount of free RAM, in megabytes.
/// </summary>
/// <param name="mono">Whether or not this program is being executed in a Mono runtime</param>
/// <returns>Free RAM memory amount, in megabytes</returns>
public long GetFreeSystemRam(bool mono)
{
if (mono)
{
//Temporary in case mono won't work
if (File.Exists("/proc/meminfo"))
{
var l = File.ReadAllLines("/proc/meminfo");
foreach (string s in l)
{
if (s.StartsWith("MemFree:"))
{
var m = Regex.Match(s, "MemFree:(\\s*)(\\d*) kB");
if (m.Success)
{
long val;
if (long.TryParse(m.Groups[2].Value, out val))
{
return val / 1024;
}
}
}
}
}
return -1;
}
else
{
var pc = new PerformanceCounter("Memory", "Available MBytes");
return pc.RawValue;
}
}
/// <summary>
/// Returns the total amount of installed RAM, in gigabytes.
/// </summary>
/// <param name="isMono">Whether or not this program is being executed in a Mono runtime</param>
/// <returns>Total RAM memory amount, in gigabytes</returns>
public long GetTotalSystemRam(bool isMono)
{
if (totalMem != 0)
{
return totalMem; //Return early
}
if (isMono) //Set totalMem so it can be returned later
{
var pc = new PerformanceCounter("Mono Memory", "Total Physical Memory");
totalMem = (pc.RawValue / 1024 / 1024 / 1024);
}
else
{
GetPhysicallyInstalledSystemMemory(out totalMem);
totalMem = (totalMem / 1024 / 1024); // Super hardcore maths to convert to Gb from Kb
}
return totalMem;
}
}
/// <summary>
/// Holding information regarding loaded plugins
/// </summary>
public struct PluginItem
{
/// <summary>
/// Plugin name
/// </summary>
public string name;
/// <summary>
/// Assembly version
/// </summary>
public string version;
/// <summary>
/// Api version or UNKNOWN if attribute is missing, which is currently impossible
/// </summary>
public string apiVersion;
}
/// <summary>
/// Contains JSON-Serializable information about a server
/// </summary>
public struct JsonData
{
/// <summary>
/// The port the server is running on
/// </summary>
public int port;
/// <summary>
/// The number of players currently on the server
/// </summary>
public int currentPlayers;
/// <summary>
/// The maximum number of player slots available on the server
/// </summary>
public int maxPlayers;
/// <summary>
/// The amount of RAM installed on the server's host PC
/// </summary>
public long systemRam;
/// <summary>
/// The TShock version being used by the server
/// </summary>
public string version;
/// <summary>
/// Whether or not server was started with --ignoreversion
/// </summary>
public bool ignorePluginVersion;
/// <summary>
/// List of loaded plugins and version name:
/// </summary>
public PluginItem[] loadedPlugins;
/// <summary>
/// The Terraria version supported by the server
/// </summary>
public string terrariaVersion;
/// <summary>
/// The provider ID set for the server
/// </summary>
public string providerId;
/// <summary>
/// The server ID set for the server
/// </summary>
public string serverId;
/// <summary>
/// Whether or not the server is running with Mono
/// </summary>
public bool mono;
}
}

3
TShockAPI/TSPlayer.cs
View file

@ -228,8 +228,6 @@ namespace TShockAPI
/// </summary>
public DateTime LastThreat { get; set; }
public bool InitSpawn;
/// <summary>
/// Whether the player should see logs.
/// </summary>
@ -1520,7 +1518,6 @@ namespace TShockAPI
{
Main.player[Index].team = team;
NetMessage.SendData((int)PacketTypes.PlayerTeam, -1, -1, NetworkText.Empty, Index);
NetMessage.SendData((int)PacketTypes.PlayerTeam, -1, Index, NetworkText.Empty, Index);
}
private DateTime LastDisableNotification = DateTime.UtcNow;

13
TShockAPI/TShock.cs
View file

@ -116,8 +116,6 @@ namespace TShockAPI
public static RestManager RestManager;
/// <summary>Utils - Static reference to the utilities class, which contains a variety of utility functions.</summary>
public static Utils Utils = Utils.Instance;
/// <summary>StatTracker - Static reference to the stat tracker, which sends some server metrics every 5 minutes.</summary>
public static StatTracker StatTracker = new StatTracker();
/// <summary>UpdateManager - Static reference to the update checker, which checks for updates and notifies server admins of updates.</summary>
public static UpdateManager UpdateManager;
/// <summary>Log - Static reference to the log system, which outputs to either SQL or a text file, depending on user config.</summary>
@ -334,12 +332,6 @@ namespace TShockAPI
Log.ConsoleInfo("TShock {0} ({1}) now running.", Version, VersionCodename);
var systemRam = StatTracker.GetFreeSystemRam(ServerApi.RunningMono);
if (systemRam > -1 && systemRam < 2048)
{
Log.ConsoleError("This machine has less than 2 gigabytes of RAM free. Be advised that it might not be enough to run TShock.");
}
ServerApi.Hooks.GamePostInitialize.Register(this, OnPostInit);
ServerApi.Hooks.GameUpdate.Register(this, OnUpdate);
ServerApi.Hooks.GameHardmodeTileUpdate.Register(this, OnHardUpdate);
@ -763,13 +755,11 @@ namespace TShockAPI
}
})
.AddFlag("--provider-token", (token) => StatTracker.ProviderToken = token)
//Flags without arguments
.AddFlag("-logclear", () => LogClear = true)
.AddFlag("-autoshutdown", () => Main.instance.EnableAutoShutdown())
.AddFlag("-dump", () => Utils.Dump())
.AddFlag("--stats-optout", () => StatTracker.OptOut = true);
.AddFlag("-dump", () => Utils.Dump());
CliParser.ParseFromSource(parms);
}
@ -902,7 +892,6 @@ namespace TShockAPI
}
UpdateManager = new UpdateManager();
StatTracker.Start();
}
/// <summary>LastCheck - Used to keep track of the last check for basically all time based checks.</summary>

1
TShockAPI/TShockAPI.csproj
View file

@ -145,7 +145,6 @@
<Compile Include="Rest\RestVerbs.cs" />
<Compile Include="Rest\SecureRest.cs" />
<Compile Include="ServerSideCharacters\ServerSideConfig.cs" />
<Compile Include="StatTracker.cs" />
<Compile Include="TSServerPlayer.cs" />
<Compile Include="Utils.cs" />
<Compile Include="TShock.cs" />

2
scripts/create_release.py
View file

@ -182,7 +182,7 @@ def build_software():
if __name__ == '__main__':
create_release_folder()
update_terraria_source()
run_bootstrapper();
run_bootstrapper()
copy_dependencies()
build_software()
package_release()