private object PlayerKills(RestRequestArgs args)
{
var Name = args.Parameters["name"];
// Checks if parameters exists
if (string.IsNullOrWhiteSpace(Name))
{
return(RestMissingParam("name"));
}
// Gets and checks if result (kills) are not empty
var Kills = DB.GetKills(Name);
if (Kills == null)
{
return(RestError("Invalid name"));
}
var Result = new RestObject();
foreach (var Row in Kills)
{
Result.Add(Row.Key, Row.Value);
}
return(Result);
}
private object PlayerStats(RestRequestArgs args)
{
var Name = args.Parameters["name"];
// Checks if parameters exists
if (string.IsNullOrWhiteSpace(Name))
{
return(RestMissingParam("name"));
}
// Gets and checks if result (stats) are not empty
var Stats = DB.GetStats(Name);
if (Stats == null)
{
return(RestError("Invalid name"));
}
var Result = new RestObject()
{
{ "tiles_destroyed", Stats[0] },
{ "tiles_placed", Stats[1] },
{ "deaths", Stats[2] }
};
return(Result);
}
private object Butcher(RestVerbs verbs, IParameterCollection parameters)
{
bool killFriendly;
if (!bool.TryParse(parameters["killfriendly"], out killFriendly))
{
RestObject fail = new RestObject("400");
fail["response"] = "The given value for killfriendly wasn't a boolean value.";
return(fail);
}
if (killFriendly)
{
killFriendly = !killFriendly;
}
int killcount = 0;
for (int i = 0; i < Main.npc.Length; i++)
{
if (Main.npc[i].active && Main.npc[i].type != 0 && !Main.npc[i].townNPC && (!Main.npc[i].friendly || killFriendly))
{
TSPlayer.Server.StrikeNPC(i, 99999, 90f, 1);
killcount++;
}
}
RestObject rj = new RestObject("200");
rj["response"] = killcount + " NPCs have been killed.";
return(rj);
}
private object Off(RestVerbs verbs, IParameterCollection parameters)
{
bool confirm;
bool.TryParse(parameters["confirm"], out confirm);
bool nosave;
bool.TryParse(parameters["nosave"], out nosave);
if (confirm == true)
{
if (!nosave)
{
WorldGen.saveWorld();
}
Netplay.disconnect = true;
RestObject reply = new RestObject("200");
reply["response"] = "The server is shutting down.";
return(reply);
}
RestObject fail = new RestObject("400");
fail["response"] = "Invalid/missing confirm switch, and/or missing nosave switch.";
return(fail);
}
private object PlayerList(RestVerbs verbs, IParameterCollection parameters)
{
var activeplayers = Main.player.Where(p => p != null && p.active).ToList();
string currentPlayers = string.Join(", ", activeplayers.Select(p => p.name));
var ret = new RestObject("200");
ret["players"] = currentPlayers;
return(ret);
}
private object ServerStatusV2(RestRequestArgs args)
{
var ret = new RestObject()
{
{ "name", TShock.Config.ServerName },
{ "serverversion", Main.versionNumber },
{ "tshockversion", TShock.VersionNum },
{ "port", TShock.Config.ServerPort },
{ "playercount", Main.player.Where(p => null != p && p.active).Count() },
{ "maxplayers", TShock.Config.MaxSlots },
{ "world", Main.worldName },
{ "uptime", (DateTime.Now - System.Diagnostics.Process.GetCurrentProcess().StartTime).ToString(@"d'.'hh':'mm':'ss") },
{ "serverpassword", !string.IsNullOrEmpty(TShock.Config.ServerPassword) }
};
if (GetBool(args.Parameters["players"], false))
{
var players = new ArrayList();
foreach (TSPlayer tsPlayer in TShock.Players.Where(p => null != p))
{
var p = PlayerFilter(tsPlayer, args.Parameters, ((args.TokenData.UserGroupName) != "" && TShock.Utils.GetGroup(args.TokenData.UserGroupName).HasPermission(RestPermissions.viewips)));
if (null != p)
{
players.Add(p);
}
}
ret.Add("players", players);
}
if (GetBool(args.Parameters["rules"], false))
{
var rules = new Dictionary <string, object>();
rules.Add("AutoSave", TShock.Config.AutoSave);
rules.Add("DisableBuild", TShock.Config.DisableBuild);
rules.Add("DisableClownBombs", TShock.Config.DisableClownBombs);
rules.Add("DisableDungeonGuardian", TShock.Config.DisableDungeonGuardian);
rules.Add("DisableInvisPvP", TShock.Config.DisableInvisPvP);
rules.Add("DisableSnowBalls", TShock.Config.DisableSnowBalls);
rules.Add("DisableTombstones", TShock.Config.DisableTombstones);
rules.Add("EnableWhitelist", TShock.Config.EnableWhitelist);
rules.Add("HardcoreOnly", TShock.Config.HardcoreOnly);
rules.Add("PvPMode", TShock.Config.PvPMode);
rules.Add("SpawnProtection", TShock.Config.SpawnProtection);
rules.Add("SpawnProtectionRadius", TShock.Config.SpawnProtectionRadius);
rules.Add("ServerSideInventory", Main.ServerSideCharacter);
ret.Add("rules", rules);
}
return(ret);
}
private object ServerStatusV2(RestVerbs verbs, IParameterCollection parameters)
{
if (TShock.Config.EnableTokenEndpointAuthentication)
{
return(RestError("Server settings require a token for this API call"));
}
var ret = new RestObject()
{
{ "name", TShock.Config.ServerName },
{ "port", TShock.Config.ServerPort },
{ "playercount", Main.player.Where(p => null != p && p.active).Count() },
{ "maxplayers", TShock.Config.MaxSlots },
{ "world", Main.worldName }
};
if (GetBool(parameters["players"], false))
{
var players = new ArrayList();
foreach (TSPlayer tsPlayer in TShock.Players.Where(p => null != p))
{
var p = PlayerFilter(tsPlayer, parameters);
if (null != p)
{
players.Add(p);
}
}
ret.Add("players", players);
}
if (GetBool(parameters["rules"], false))
{
var rules = new Dictionary <string, object>();
rules.Add("AutoSave", TShock.Config.AutoSave);
rules.Add("DisableBuild", TShock.Config.DisableBuild);
rules.Add("DisableClownBombs", TShock.Config.DisableClownBombs);
rules.Add("DisableDungeonGuardian", TShock.Config.DisableDungeonGuardian);
rules.Add("DisableInvisPvP", TShock.Config.DisableInvisPvP);
rules.Add("DisableSnowBalls", TShock.Config.DisableSnowBalls);
rules.Add("DisableTombstones", TShock.Config.DisableTombstones);
rules.Add("EnableWhitelist", TShock.Config.EnableWhitelist);
rules.Add("HardcoreOnly", TShock.Config.HardcoreOnly);
rules.Add("PvPMode", TShock.Config.PvPMode);
rules.Add("SpawnProtection", TShock.Config.SpawnProtection);
rules.Add("SpawnProtectionRadius", TShock.Config.SpawnProtectionRadius);
ret.Add("rules", rules);
}
return(ret);
}
private object Broadcast(RestVerbs verbs, IParameterCollection parameters)
{
if (parameters["msg"] != null && parameters["msg"].Trim() != "")
{
TShock.Utils.Broadcast(parameters["msg"]);
RestObject reply = new RestObject("200");
reply["response"] = "The message was broadcasted successfully.";
return(reply);
}
RestObject fail = new RestObject("400");
fail["response"] = "Broadcast failed.";
return(fail);
}
private object UserUpdateV2(RestVerbs verbs, IParameterCollection parameters)
{
var ret = UserFind(parameters);
if (ret is RestObject)
{
return(ret);
}
var password = parameters["password"];
var group = parameters["group"];
if (string.IsNullOrWhiteSpace(group) && string.IsNullOrWhiteSpace(password))
{
return(RestMissingParam("group", "password"));
}
User user = (User)ret;
var response = new RestObject();
if (!string.IsNullOrWhiteSpace(password))
{
try
{
TShock.Users.SetUserPassword(user, password);
response.Add("password-response", "Password updated successfully");
}
catch (Exception e)
{
return(RestError("Failed to update user password (" + e.Message + ")"));
}
}
if (!string.IsNullOrWhiteSpace(group))
{
try
{
TShock.Users.SetUserGroup(user, group);
response.Add("group-response", "Group updated successfully");
}
catch (Exception e)
{
return(RestError("Failed to update user group (" + e.Message + ")"));
}
}
return(response);
}
private object AllPlayersKills(RestRequestArgs args)
{
// Gets and checks if result (kills) are not empty
var AllKills = DB.GetAllKills();
if (AllKills == null)
{
return RestError("Empty database");
}
var Result = new RestObject();
foreach (var Row in AllKills)
{
Result.Add(Row.Key, Row.Value);
}
return Result;
}
private object AllPlayersKills(RestRequestArgs args)
{
// Gets and checks if result (kills) are not empty
var AllKills = DB.GetAllKills();
if (AllKills == null)
{
return(RestError("Empty database"));
}
var Result = new RestObject();
foreach (var Row in AllKills)
{
Result.Add(Row.Key, Row.Value);
}
return(Result);
}
private object ServerCommand(RestVerbs verbs, IParameterCollection parameters)
{
if (parameters["cmd"] != null && parameters["cmd"].Trim() != "")
{
TSRestPlayer tr = new TSRestPlayer();
RestObject ro = new RestObject("200");
Commands.HandleCommand(tr, parameters["cmd"]);
foreach (string s in tr.GetCommandOutput())
{
ro.Add("response", s);
}
return(ro);
}
RestObject fail = new RestObject("400");
fail["response"] = "Missing or blank cmd parameter.";
return(fail);
}
private List <RestRequest> DeserializedMultiRequest(MultirequestController multirequestController, JObject jObject)
{
List <RestRequest> requests = new List <RestRequest>();
int index = 1;
while (jObject[index.ToString()] != null)
{
JObject jRequest = (JObject)jObject[index.ToString()];
RestRequest request = new RestRequest();
request.Service = jRequest["service"].ToString();
request.Action = jRequest["action"].ToString();
request.Arguments = new Dictionary <string, object>();
MethodInfo methodInfo = multirequestController.GetMethodInfo(request.Service, request.Action);
foreach (ParameterInfo parameterInfo in methodInfo.GetParameters())
{
string name = parameterInfo.Name;
JToken jToken = jRequest[name];
if (jToken == null || jToken.Type == JTokenType.Null)
{
if (!parameterInfo.IsOptional)
{
throw new RestRequestException(RestRequestException.MISSING_PARAMETER, name);
}
}
else if (jToken.Type == JTokenType.String && MultirequestController.MultirequestRegex.IsMatch((string)jToken))
{
request.Arguments.Add(name, (string)jToken);
}
else
{
request.Arguments.Add(name, RestObject.FromJson(parameterInfo.ParameterType, jToken));
}
}
requests.Add(request);
index++;
}
return(requests);
}
private object UserList(RestVerbs verbs, IParameterCollection parameters)
{
var ret = new RestObject("200");
string playerlist = "";
foreach (var TSPlayer in TShock.Players)
{
if (playerlist == "")
{
playerlist += TSPlayer.UserAccountName;
}
else
{
playerlist += ", " + TSPlayer.UserAccountName;
}
}
ret["activeuesrs"] = playerlist;
return(ret);
}
public void TestRequestAndResponseWithNulls()
{
//Just to make it more readable
var quote = "\"";
var openBracket = "{";
var closeBracket = "}";
var comma = ",";
var colon = ":";
var crlf = "";
var json = TestRESTRequestResponse.CreateString(openBracket, crlf,
quote, "TestStringValue", quote, colon, quote, TestRESTObject.TEST_STRING, quote, comma, crlf,
quote, "TestBoolValue", quote, colon, TestRESTObject.TEST_BOOL.ToString().ToLower(), comma, crlf,
quote, "TestIntValue", quote, colon, TestRESTObject.TEST_INT.ToString(), comma, crlf,
quote, "TestLongValue", quote, colon, TestRESTObject.TEST_LONG.ToString(), comma, crlf,
quote, "TestByteValue", quote, colon, TestRESTObject.TEST_BYTE.ToString(), comma, crlf,
quote, "TestUnsignedIntValue", quote, colon, TestRESTObject.TEST_UINT.ToString(), comma, crlf,
quote, "TestFloatValue", quote, colon, TestRESTObject.TEST_FLOAT.ToString("R"), comma, crlf,
quote, "TestDoubleValue", quote, colon, TestRESTObject.TEST_DOUBLE.ToString("R"), comma, crlf,
quote, "TestCharValue", quote, colon, quote, TestRESTObject.TEST_CHAR.ToString(), quote, comma, crlf,
quote, "TestDateTimeValue", quote, colon, TestRESTObject.TEST_DATETIME.Subtract(TestRESTRequestResponse.UNIX_EPOCH).TotalSeconds.ToString(), comma, crlf,
quote, "ChildArray", quote, colon, "null", comma, crlf,
quote, "ChildList", quote, colon, "null", crlf,
closeBracket
);
Assert.IsTrue(json != null);
// {"TestStringValue":"Test","TestBoolValue":true,"TestIntValue":-2147483648,"TestLongValue":9223372036854775807,"TestByteValue":250,"TestUnsignedIntValue":4294967295,"TestFloatValue":3.40282347E+38,"TestDoubleValue":1.7976931348623157E+308,"TestCharValue":"A","TestDateTime":6/3/1987 2:34:00 AM,"ChildArray":null,"ChildList":null}
// {"TestStringValue":"Test","TestBoolValue":true,"TestIntValue":-2147483648,"TestLongValue":9223372036854775807,"TestByteValue":250,"TestUnsignedIntValue":4294967295,"TestFloatValue":3.40282347E+38,"TestDoubleValue":1.7976931348623157E+308,"TestCharValue":"A","TestDateTimeValue":"1987-06-03T02:34:00","TestNullableStringValue":"Test","TestNullableBoolValue":true,"TestNullableIntValue":-2147483648,"TestNullableLongValue":9223372036854775807,"TestNullableByteValue":250,"TestNullableUIntValue":4294967295,"TestNullableFloatValue":3.40282347E+38,"TestNullableDoubleValue":1.7976931348623157E+308,"TestNullableCharValue":"A","TestNullableDateTimeValue":"1987-06-03T02:34:00","ChildArray":null,"ChildList":null}
var request = TestRESTRequestResponse.CreateTestHttpRequest(TestRESTRequestResponse.CreateTestHttpResponse(json));
request.Method = "GET";
Assert.IsNotNull(request);
var testRequest = new RestWebRequest(request);
Assert.IsNotNull(testRequest);
var testResponse = testRequest.GetRestResponse();
Assert.IsNotNull(testResponse);
var testObject = new RestObject<TestRESTObject>(testResponse);
Assert.IsNotNull(testObject);
var testExplicit = testObject.ExplicitObject;
Assert.IsNotNull(testExplicit);
TestRESTObject.AssertValidValuesForTestClass(testExplicit, false, false, false, false);
}
//---------------------------------------------------------------------
public override void Validate(object sender, ValidationEventArgs e)
{
RestObject response = ValidateJson(sender, e);
if (null == response)
{
return;
}
foreach (var p in PropertyNames.Split(','))
{
if (null == response[p])
{
e.Message = String.Format("'{0}' Not Found", p);
e.IsValid = false;
return;
}
}
e.IsValid = true;
//e.WebTest.Context.Add(ContextParameterName, propertyValue);
}
public RestObject ValidateJson(object sender, ValidationEventArgs e)
{
if (string.IsNullOrWhiteSpace(e.Response.BodyString))
{
e.IsValid = false;
e.Message = String.Format("Empty or null response {0}", e.Response.StatusCode);
return(null);
}
JavaScriptSerializer serialiser = new JavaScriptSerializer();
//dynamic data = serialiser.Deserialize<dynamic>(e.Response.BodyString);
RestObject response = serialiser.Deserialize <RestObject>(e.Response.BodyString);
if (JSonStatus != response.Status)
{
e.IsValid = false;
e.Message = String.Format("Response Status '{0}' not '{1}'", response.Status, JSonStatus);
return(null);
}
return(response);
}
public override void Validate(object sender, ValidationEventArgs e)
{
RestObject response = ValidateJson(sender, e);
if (null == response)
{
return;
}
if (null == response[PropertyName])
{
e.Message = String.Format("{0} Not Found", PropertyName);
e.IsValid = false;
return;
}
if (UseRegularExpression)
{
var re = new Regex(PropertyValue);
if (!re.IsMatch((string)response[PropertyName]))
{
e.Message = String.Format("{0} => '{1}' !~ '{2}'", PropertyName, response[PropertyName], PropertyValue);
e.IsValid = false;
return;
}
}
else
{
if (PropertyValue != (string)response[PropertyName])
{
e.Message = String.Format("{0} => '{1}' != '{2}'", PropertyName, response[PropertyName], PropertyValue);
e.IsValid = false;
return;
}
}
e.IsValid = true;
//e.WebTest.Context.Add(ContextParameterName, propertyValue);
}
private object Status(RestVerbs verbs, IParameterCollection parameters)
{
if (TShock.Config.EnableTokenEndpointAuthentication)
{
return new RestObject("403")
{
Error = "Server settings require a token for this API call."
}
}
;
var activeplayers = Main.player.Where(p => p != null && p.active).ToList();
string currentPlayers = string.Join(", ", activeplayers.Select(p => p.name));
var ret = new RestObject("200");
ret["name"] = TShock.Config.ServerNickname;
ret["port"] = Convert.ToString(TShock.Config.ServerPort);
ret["playercount"] = Convert.ToString(activeplayers.Count());
ret["players"] = currentPlayers;
return(ret);
}
private object AllPlayersStats(RestRequestArgs args)
{
// Gets and checks if result (stats) are not empty
var AllStats = DB.GetAllStats();
if (AllStats == null)
{
return(RestError("Empty database"));
}
var Result = new RestObject();
foreach (var Row in AllStats)
{
Result.Add(Row.Key, new Dictionary <string, int>()
{
{ "tiles_destroyed", Row.Value[0] },
{ "tiles_placed", Row.Value[1] },
{ "deaths", Row.Value[2] }
});
}
return(Result);
}
private Dictionary <string, object> DeserializeActionParameters(JObject jObject, List <HttpParameterDescriptor> propertiesDescriptors)
{
Dictionary <string, object> outputArguments = new Dictionary <string, object>();
foreach (HttpParameterDescriptor propertyDescriptor in propertiesDescriptors)
{
string name = propertyDescriptor.ParameterName;
JToken jToken = jObject[name];
if (jToken == null || jToken.Type == JTokenType.Null)
{
if (!propertyDescriptor.IsOptional)
{
throw new RestRequestException(RestRequestException.MISSING_PARAMETER, name);
}
}
else
{
outputArguments.Add(name, RestObject.FromJson(propertyDescriptor.ParameterType, jToken));
}
}
return(outputArguments);
}
public DomainFIPAclTemplateEntriesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(DomainFIPAclTemplateEntry))
{
}
private object NewTokenV2(RestVerbs verbs, IParameterCollection parameters)
{
var user = parameters["username"];
var pass = verbs["password"];
RestObject obj = null;
if (Verify != null)
obj = Verify(user, pass);
if (obj == null)
obj = new RestObject("401") { Error = "Invalid username/password combination provided. Please re-submit your query with a correct pair." };
if (obj.Error != null)
return obj;
string hash;
var rand = new Random();
var randbytes = new byte[32];
do
{
rand.NextBytes(randbytes);
hash = randbytes.Aggregate("", (s, b) => s + b.ToString("X2"));
} while (Tokens.ContainsKey(hash));
Tokens.Add(hash, user);
obj["token"] = hash;
return obj;
}
public ZFBAutoAssignmentsFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(ZFBAutoAssignment))
{
}
private object ServerStatusV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = new RestObject()
{
{"name", TShock.Config.ServerName},
{"port", TShock.Config.ServerPort},
{"playercount", Main.player.Where(p => null != p && p.active).Count()},
{"maxplayers", TShock.Config.MaxSlots},
{"world", Main.worldName},
{"uptime", (DateTime.Now - System.Diagnostics.Process.GetCurrentProcess().StartTime).ToString(@"d'.'hh':'mm':'ss")},
{"serverpassword", !string.IsNullOrEmpty(TShock.Config.ServerPassword)}
};
if (GetBool(parameters["players"], false))
{
var players = new ArrayList();
foreach (TSPlayer tsPlayer in TShock.Players.Where(p => null != p))
{
var p = PlayerFilter(tsPlayer, parameters, ((tokenData.UserGroupName) != "" && TShock.Utils.GetGroup(tokenData.UserGroupName).HasPermission(RestPermissions.viewips)));
if (null != p)
players.Add(p);
}
ret.Add("players", players);
}
if (GetBool(parameters["rules"], false))
{
var rules = new Dictionary<string,object>();
rules.Add("AutoSave", TShock.Config.AutoSave);
rules.Add("DisableBuild", TShock.Config.DisableBuild);
rules.Add("DisableClownBombs", TShock.Config.DisableClownBombs);
rules.Add("DisableDungeonGuardian", TShock.Config.DisableDungeonGuardian);
rules.Add("DisableInvisPvP", TShock.Config.DisableInvisPvP);
rules.Add("DisableSnowBalls", TShock.Config.DisableSnowBalls);
rules.Add("DisableTombstones", TShock.Config.DisableTombstones);
rules.Add("EnableWhitelist", TShock.Config.EnableWhitelist);
rules.Add("HardcoreOnly", TShock.Config.HardcoreOnly);
rules.Add("PvPMode", TShock.Config.PvPMode);
rules.Add("SpawnProtection", TShock.Config.SpawnProtection);
rules.Add("SpawnProtectionRadius", TShock.Config.SpawnProtectionRadius);
rules.Add("ServerSideInventory", TShock.Config.ServerSideCharacter);
ret.Add("rules", rules);
}
return ret;
}
private object PlayerKills(RestRequestArgs args)
{
var Name = args.Parameters["name"];
// Checks if parameters exists
if (string.IsNullOrWhiteSpace(Name))
{
return RestMissingParam("name");
}
// Gets and checks if result (kills) are not empty
var Kills = DB.GetKills(Name);
if (Kills == null)
{
return RestError("Invalid name");
}
var Result = new RestObject();
foreach (var Row in Kills)
{
Result.Add(Row.Key, Row.Value);
}
return Result;
}
public IngressProfilesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(IngressProfile))
{
}
private RestObject NewTokenInternal(string username, string password, IHttpContext context)
{
int tokens = 0;
if (tokenBucket.TryGetValue(context.RemoteEndPoint.Address.ToString(), out tokens))
{
if (tokens >= Math.Max(TShock.Config.RESTMaximumRequestsPerInterval, 5))
{
TShock.Log.ConsoleError("A REST login from {0} was blocked as it currently has {1} tokens", context.RemoteEndPoint.Address.ToString(), tokens);
tokenBucket[context.RemoteEndPoint.Address.ToString()] += 1; // Tokens over limit, increment by one and reject request
return new RestObject("403")
{
Error = "Username or password may be incorrect or this account may not have sufficient privileges."
};
}
if (!TShock.Config.RESTLimitOnlyFailedLoginRequests)
tokenBucket[context.RemoteEndPoint.Address.ToString()] += 1; // Tokens under limit, increment by one and process request
}
else
{
if (!TShock.Config.RESTLimitOnlyFailedLoginRequests)
tokenBucket.Add(context.RemoteEndPoint.Address.ToString(), 1); // First time request, set to one and process request
}
User userAccount = TShock.Users.GetUserByName(username);
if (userAccount == null)
{
AddTokenToBucket(context.RemoteEndPoint.Address.ToString());
return new RestObject("403") { Error = "Username or password may be incorrect or this account may not have sufficient privileges." };
}
if (!userAccount.VerifyPassword(password))
{
AddTokenToBucket(context.RemoteEndPoint.Address.ToString());
return new RestObject("403") { Error = "Username or password may be incorrect or this account may not have sufficient privileges." };
}
Group userGroup = TShock.Utils.GetGroup(userAccount.Group);
if (!userGroup.HasPermission(RestPermissions.restapi) && userAccount.Group != "superadmin")
{
AddTokenToBucket(context.RemoteEndPoint.Address.ToString());
return new RestObject("403")
{ Error = "Username or password may be incorrect or this account may not have sufficient privileges." };
}
string tokenHash;
var rand = new Random();
var randbytes = new byte[32];
do
{
rand.NextBytes(randbytes);
tokenHash = randbytes.Aggregate("", (s, b) => s + b.ToString("X2"));
} while (Tokens.ContainsKey(tokenHash));
Tokens.Add(tokenHash, new TokenData { Username = userAccount.Name, UserGroupName = userGroup.Name });
AddTokenToBucket(context.RemoteEndPoint.Address.ToString());
RestObject response = new RestObject() { Response = "Successful login" };
response["token"] = tokenHash;
return response;
}
public L2DomainTemplatesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(L2DomainTemplate))
{
}
public IPv6FilterProfilesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(IPv6FilterProfile))
{
}
private object ChangeWorldSaveSettings(RestVerbs verbs, IParameterCollection parameters)
{
bool state;
bool.TryParse(verbs["state"], out state);
if (state == true)
{
TShock.Config.AutoSave = true;
}
else
{
TShock.Config.AutoSave = false;
}
RestObject rj = new RestObject("200");
rj["response"] = "Value changed";
rj["state"] = state;
return rj;
}
private object WorldSave(RestVerbs verbs, IParameterCollection parameters)
{
TShock.Utils.SaveWorld();
RestObject rj = new RestObject("200");
rj["response"] = "World saved.";
return rj;
}
public void TestRequestAndResponseWithoutNulls()
{
//Just to make it more readable
var quote = "\"";
var openBracket = "{";
var closeBracket = "}";
var comma = ",";
var colon = ":";
var crlf = "";
// "R" formatting preserves the most precision for float/double
var json = TestRESTRequestResponse.CreateString(openBracket, crlf,
quote, "TestStringValue", quote, colon, quote, TestRESTObject.TEST_STRING, quote, comma, crlf,
quote, "TestBoolValue", quote, colon, TestRESTObject.TEST_BOOL.ToString().ToLower(), comma, crlf,
quote, "TestIntValue", quote, colon, TestRESTObject.TEST_INT.ToString(), comma, crlf,
quote, "TestLongValue", quote, colon, TestRESTObject.TEST_LONG.ToString(), comma, crlf,
quote, "TestByteValue", quote, colon, TestRESTObject.TEST_BYTE.ToString(), comma, crlf,
quote, "TestUnsignedIntValue", quote, colon, TestRESTObject.TEST_UINT.ToString(), comma, crlf,
quote, "TestFloatValue", quote, colon, TestRESTObject.TEST_FLOAT.ToString("R"), comma, crlf,
quote, "TestDoubleValue", quote, colon, TestRESTObject.TEST_DOUBLE.ToString("R"), comma, crlf,
quote, "TestCharValue", quote, colon, quote, TestRESTObject.TEST_CHAR.ToString(), quote, comma, crlf,
quote, "TestDateTimeValue", quote, colon, TestRESTObject.TEST_DATETIME.Subtract(TestRESTRequestResponse.UNIX_EPOCH).TotalSeconds.ToString(), comma, crlf,
quote, "TestNullableStringValue", quote, colon, quote, TestRESTObject.TEST_STRING, quote, comma, crlf,
quote, "TestNullableBoolValue", quote, colon, TestRESTObject.TEST_BOOL.ToString().ToLower(), comma, crlf,
quote, "TestNullableIntValue", quote, colon, TestRESTObject.TEST_INT.ToString(), comma, crlf,
quote, "TestNullableLongValue", quote, colon, TestRESTObject.TEST_LONG.ToString(), comma, crlf,
quote, "TestNullableByteValue", quote, colon, TestRESTObject.TEST_BYTE.ToString(), comma, crlf,
quote, "TestNullableUIntValue", quote, colon, TestRESTObject.TEST_UINT.ToString(), comma, crlf,
quote, "TestNullableFloatValue", quote, colon, TestRESTObject.TEST_FLOAT.ToString("R"), comma, crlf,
quote, "TestNullableDoubleValue", quote, colon, TestRESTObject.TEST_DOUBLE.ToString("R"), comma, crlf,
quote, "TestNullableCharValue", quote, colon, quote, TestRESTObject.TEST_CHAR.ToString(), quote, comma, crlf,
quote, "TestNullableDateTimeValue", quote, colon, TestRESTObject.TEST_DATETIME.Subtract(TestRESTRequestResponse.UNIX_EPOCH).TotalSeconds.ToString(), comma, crlf,
quote, "ChildArray", quote, colon, "null", comma, crlf,
quote, "ChildList", quote, colon, "null", crlf,
closeBracket
);
Assert.IsTrue(json != null);
var request = TestRESTRequestResponse.CreateTestHttpRequest(TestRESTRequestResponse.CreateTestHttpResponse(json));
request.Method = "GET";
Assert.IsNotNull(request);
var testRequest = new RestWebRequest(request);
Assert.IsNotNull(testRequest);
var testResponse = testRequest.GetRestResponse();
Assert.IsNotNull(testResponse);
var testObject = new RestObject<TestRESTObject>(testResponse);
Assert.IsNotNull(testObject);
var testExplicit = testObject.ExplicitObject;
Assert.IsNotNull(testExplicit);
TestRESTObject.AssertValidValuesForTestClass(testExplicit, false, false, false, true);
}
private object Broadcast(RestVerbs verbs, IParameterCollection parameters)
{
if (parameters["msg"] != null && parameters["msg"].Trim() != "")
{
TShock.Utils.Broadcast(parameters["msg"]);
RestObject reply = new RestObject("200");
reply["response"] = "The message was broadcasted successfully.";
return reply;
}
RestObject fail = new RestObject("400");
fail["response"] = "Broadcast failed.";
return fail;
}
private object Butcher(RestVerbs verbs, IParameterCollection parameters)
{
bool killFriendly;
if (!bool.TryParse(parameters["killfriendly"], out killFriendly))
{
RestObject fail = new RestObject("400");
fail["response"] = "The given value for killfriendly wasn't a boolean value.";
return fail;
}
if (killFriendly)
{
killFriendly = !killFriendly;
}
int killcount = 0;
for (int i = 0; i < Main.npc.Length; i++)
{
if (Main.npc[i].active && Main.npc[i].type != 0 && !Main.npc[i].townNPC && (!Main.npc[i].friendly || killFriendly))
{
TSPlayer.Server.StrikeNPC(i, 99999, 90f, 1);
killcount++;
}
}
RestObject rj = new RestObject("200");
rj["response"] = killcount + " NPCs have been killed.";
return rj;
}
public static RestObject<TestRESTObject> SerializeAndParseRESTObject(TestRESTObject testObject)
{
var json = JsonConvert.SerializeObject(testObject);
var restObject = new RestObject<TestRESTObject>(json);
//Check to make sure that serialization was correct
Assert.IsTrue(restObject.ExplicitObject != null, "Explicit Object was not correctly populated");
return restObject;
}
private object getServerVersion(RestRequestArgs args)
{
var ret = new RestObject()
{
{"name", TShock.Config.ServerName},
{"serverversion", Main.versionNumber.ToString()},
{"tshockversion", TShock.VersionNum.ToString()},
{"port", TShock.Config.ServerPort},
{"APIversion", TerrariaApi.Server.ServerApi.ApiVersion.Major + "." + TerrariaApi.Server.ServerApi.ApiVersion.Minor}
};
return ret;
}
protected virtual object ProcessRequest(object sender, HttpListenerContext e)
{
try
{
var uri = e.Request.Url.AbsolutePath;
uri = uri.TrimEnd('/');
foreach (var com in commands)
{
var verbs = new RestVerbs();
if (com.HasVerbs)
{
var match = Regex.Match(uri, com.UriVerbMatch);
if (!match.Success)
continue;
if ((match.Groups.Count - 1) != com.UriVerbs.Length)
continue;
for (int i = 0; i < com.UriVerbs.Length; i++)
verbs.Add(com.UriVerbs[i], match.Groups[i + 1].Value);
}
else if (com.UriTemplate.ToLower() != uri.ToLower())
{
continue;
}
var nvc = new NameValueCollection();
CopyCollection(e.Request.QueryString, nvc);
CopyCollection(GetFormData(e), nvc);
//This overwrites get collisions with post data.
var obj = ExecuteCommand(com, verbs, nvc);
if (obj != null)
return obj;
}
}
catch (Exception exception)
{
var eobj = new RestObject(500)
{
Error = exception.Message
};
eobj["stacktrace"] = Convert.ToBase64String(Encoding.UTF8.GetBytes(exception.StackTrace));
return eobj;
}
return new RestObject(404)
{
Error = "Specified API endpoint doesn't exist. Refer to the documentation for a list of valid endpoints.",
};
}
private object PlayerStats(RestRequestArgs args)
{
var Name = args.Parameters["name"];
// Checks if parameters exists
if (string.IsNullOrWhiteSpace(Name))
{
return RestMissingParam("name");
}
// Gets and checks if result (stats) are not empty
var Stats = DB.GetStats(Name);
if (Stats == null)
{
return RestError("Invalid name");
}
var Result = new RestObject()
{
{"tiles_destroyed", Stats[0]},
{"tiles_placed", Stats[1]},
{"deaths", Stats[2]}
};
return Result;
}
public SaaSApplicationTypesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(SaaSApplicationType))
{
}
private object UserList(RestVerbs verbs, IParameterCollection parameters)
{
var ret = new RestObject("200");
string playerlist = "";
foreach (var TSPlayer in TShock.Players)
{
if (playerlist == "")
{
playerlist += TSPlayer.UserAccountName;
} else
{
playerlist += ", " + TSPlayer.UserAccountName;
}
}
ret["activeuesrs"] = playerlist;
return ret;
}
private object ServerCommand(RestVerbs verbs, IParameterCollection parameters)
{
if (parameters["cmd"] != null && parameters["cmd"].Trim() != "")
{
TSRestPlayer tr = new TSRestPlayer();
RestObject ro = new RestObject("200");
Commands.HandleCommand(tr, parameters["cmd"]);
foreach (string s in tr.GetCommandOutput())
{
ro.Add("response", s);
}
return ro;
}
RestObject fail = new RestObject("400");
fail["response"] = "Missing or blank cmd parameter.";
return fail;
}
public NetconfGlobalConfigurationsFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(NetconfGlobalConfiguration))
{
}
object Status(RestVerbs verbs, IParameterCollection parameters)
{
if (TShock.Config.EnableTokenEndpointAuthentication)
return new RestObject("403") { Error = "Server settings require a token for this API call." };
var activeplayers = Main.player.Where(p => p != null && p.active).ToList();
string currentPlayers = string.Join(", ", activeplayers.Select(p => p.name));
var ret = new RestObject("200");
ret["name"] = TShock.Config.ServerNickname;
ret["port"] = Convert.ToString(TShock.Config.ServerPort);
ret["playercount"] = Convert.ToString(activeplayers.Count());
ret["players"] = currentPlayers;
return ret;
}
public OSPFInterfacesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(OSPFInterface))
{
}
object UserList(RestVerbs verbs, IParameterCollection parameters)
{
var activeplayers = Main.player.Where(p => p != null && p.active).ToList();
string currentPlayers = string.Join(", ", activeplayers.Select(p => p.name));
var ret = new RestObject("200");
ret["players"] = currentPlayers;
return ret;
}
private object UserUpdateV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = UserFind(parameters);
if (ret is RestObject)
return ret;
var password = parameters["password"];
var group = parameters["group"];
if (string.IsNullOrWhiteSpace(group) && string.IsNullOrWhiteSpace(password))
return RestMissingParam("group", "password");
User user = (User)ret;
var response = new RestObject();
if (!string.IsNullOrWhiteSpace(password))
{
try
{
TShock.Users.SetUserPassword(user, password);
response.Add("password-response", "Password updated successfully");
}
catch (Exception e)
{
return RestError("Failed to update user password (" + e.Message + ")");
}
}
if (!string.IsNullOrWhiteSpace(group))
{
try
{
TShock.Users.SetUserGroup(user, group);
response.Add("group-response", "Group updated successfully");
}
catch (Exception e)
{
return RestError("Failed to update user group (" + e.Message + ")");
}
}
return response;
}
private object AllPlayersStats(RestRequestArgs args)
{
// Gets and checks if result (stats) are not empty
var AllStats = DB.GetAllStats();
if (AllStats == null)
{
return RestError("Empty database");
}
var Result = new RestObject();
foreach (var Row in AllStats)
{
Result.Add(Row.Key, new Dictionary<string, int>(){
{"tiles_destroyed", Row.Value[0]},
{"tiles_placed", Row.Value[1]},
{"deaths", Row.Value[2]}});
}
return Result;
}
public RolesFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(Role))
{
}
private object ServerStatusV2(RestVerbs verbs, IParameterCollection parameters)
{
if (TPulse.Config.EnableTokenEndpointAuthentication)
return RestError("Server settings require a token for this API call");
var ret = new RestObject()
{
{"name", TPulse.Config.ServerName},
{"port", TPulse.Config.ServerPort},
{"playercount", Main.player.Where(p => null != p && p.active).Count()},
{"maxplayers", TPulse.Config.MaxSlots},
{"world", Main.worldName}
};
if (GetBool(parameters["players"], false))
{
var players = new ArrayList();
foreach (TPPlayer tsPlayer in TPulse.Players.Where(p => null != p))
{
var p = PlayerFilter(tsPlayer, parameters);
if (null != p)
players.Add(p);
}
ret.Add("players", players);
}
if (GetBool(parameters["rules"], false))
{
var rules = new Dictionary<string,object>();
rules.Add("AutoSave", TPulse.Config.AutoSave);
rules.Add("DisableBuild", TPulse.Config.DisableBuild);
rules.Add("DisableClownBombs", TPulse.Config.DisableClownBombs);
rules.Add("DisableDungeonGuardian", TPulse.Config.DisableDungeonGuardian);
rules.Add("DisableInvisPvP", TPulse.Config.DisableInvisPvP);
rules.Add("DisableSnowBalls", TPulse.Config.DisableSnowBalls);
rules.Add("DisableTombstones", TPulse.Config.DisableTombstones);
rules.Add("EnableWhitelist", TPulse.Config.EnableWhitelist);
rules.Add("HardcoreOnly", TPulse.Config.HardcoreOnly);
rules.Add("PvPMode", TPulse.Config.PvPMode);
rules.Add("SpawnProtection", TPulse.Config.SpawnProtection);
rules.Add("SpawnProtectionRadius", TPulse.Config.SpawnProtectionRadius);
ret.Add("rules", rules);
}
return ret;
}
public TestsFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(Test))
{
}
private object Off(RestVerbs verbs, IParameterCollection parameters)
{
bool confirm;
bool.TryParse(parameters["confirm"], out confirm);
bool nosave;
bool.TryParse(parameters["nosave"], out nosave);
if (confirm == true)
{
if (!nosave)
WorldGen.saveWorld();
Netplay.disconnect = true;
RestObject reply = new RestObject("200");
reply["response"] = "The server is shutting down.";
return reply;
}
RestObject fail = new RestObject("400");
fail["response"] = "Invalid/missing confirm switch, and/or missing nosave switch.";
return fail;
}
public L4ServiceGroupsFetcher(RestObject parentRestObj)
: base(parentRestObj, typeof(L4ServiceGroup))
{
}
private RestObject NewTokenInternal(string username, string password)
{
User userAccount = TShock.Users.GetUserByName(username);
if (userAccount == null)
return new RestObject("401") { Error = "Invalid username/password combination provided. Please re-submit your query with a correct pair." };
if (!TShock.Utils.HashPassword(password).Equals(userAccount.Password, StringComparison.InvariantCultureIgnoreCase))
return new RestObject("401")
{ Error = "Invalid username/password combination provided. Please re-submit your query with a correct pair." };
Group userGroup = TShock.Utils.GetGroup(userAccount.Group);
if (!userGroup.HasPermission(RestPermissions.restapi) && userAccount.Group != "superadmin")
return new RestObject("403")
{ Error = "Although your account was successfully found and identified, your account lacks the permission required to use the API. (restapi)" };
string tokenHash;
var rand = new Random();
var randbytes = new byte[32];
do
{
rand.NextBytes(randbytes);
tokenHash = randbytes.Aggregate("", (s, b) => s + b.ToString("X2"));
} while (Tokens.ContainsKey(tokenHash));
Tokens.Add(tokenHash, new TokenData { Username = userAccount.Name, UserGroupName = userGroup.Name });
RestObject response = new RestObject() { Response = "Successful login" };
response["token"] = tokenHash;
return response;
}
