private object CanUserLogin(Network.Connection connection)
{
int dayCount, weekCount;
string today = DateTime.Now.ToString("MM/dd/yyyy");
string week = WeekOfYear();
string id = connection.userid.ToString();
if (timeData[id, today] == null)
{
timeData[id, today] = 0;
}
if (timeData[id, week] == null)
{
timeData[id, week] = 0;
}
dayCount = (int)timeData[id, today];
weekCount = (int)timeData[id, week];
if (config.minutesPerDay > 0 && dayCount != null && dayCount >= config.minutesPerDay)
{
string error = string.Format(lang.GetMessage("LoginDay", this, id), FormatTimeSpan((long)TimeTilNextDayCycle().TotalMinutes));
return(error);
}
else if (config.minutesPerWeek > 0 && weekCount != null && weekCount >= config.minutesPerWeek)
{
string error = string.Format(lang.GetMessage("LoginWeek", this, id), FormatTimeSpan2((long)TimeTilNextWeekCycle().TotalMinutes));
return(error);
}
return(null);
}
void OnUserApprove(Network.Connection connection)
{
if (apikey != "")
{
var url = string.Format("http://api.steampowered.com/ISteamUser/GetPlayerBans/v1/?key={0}&steamids={1}", apikey, connection.userid.ToString());
Interface.GetMod().GetLibrary <WebRequests>("WebRequests").EnqueueGet(url, (code, response) =>
{
if (code != 200)
{
return;
}
var jsonresponse = JsonConvert.DeserializeObject <Dictionary <string, object> >(response, jsonsettings);
if (!(jsonresponse["players"] is List <object>))
{
return;
}
if (!(((List <object>)jsonresponse["players"])[0] is Dictionary <string, object>))
{
return;
}
var playerdata = ((List <object>)jsonresponse["players"])[0] as Dictionary <string, object>;
if (Convert.ToInt32(playerdata["NumberOfVACBans"]) < maxAllowed)
{
return;
}
Network.Net.sv.Kick(connection, reason);
}
, this);
}
}
private object OnUserApprove(Network.Connection connection)
{
// Call out and see if we should reject
object canlogin = Interface.CallHook("CanClientLogin", new object[] { connection });
if (canlogin != null)
{
// If it's a bool and it's true, let them in
if (canlogin is bool && (bool)canlogin)
{
return(null);
}
// If it's a string, reject them with a message
if (canlogin is string)
{
ConnectionAuth.Reject(connection, (string)canlogin);
return(true);
}
// We don't know what type it is, reject them with it anyway
ConnectionAuth.Reject(connection, canlogin.ToString());
return(true);
}
return(null);
}
private bool CanBypassQueue(Network.Connection connection)
{
PrintWarning($"Can {connection.username} ({connection.userid}) bypass the queue? Yes.");
HookCalled("CanBypassQueue");
return(true);
}
object CanClientLogin(Network.Connection conn)
{
var steamId = conn.userid.ToString();
var username = conn.username;
// Foreach stored player check if the steamId
// exists for a different username
foreach (var player in storedData.Players)
{
if (player.SteamId == steamId)
{
if (player.Username != username)
{
Puts("Fail login");
return("Username changes are not allowed. You must log in with username: "******"Saving user to datafile");
storedData.Players.Add(info);
Interface.Oxide.DataFileSystem.WriteObject("NoNameChange", storedData);
}
return(true);
}
void CanClientLogin(Network.Connection connection)
{
if (APIKey == defaultAPIKey || APIKey == "")
{
Log("Error! No Steam API key found.");
Log("You need to set your API key in the configuration file for this plugin to work!");
Log("To obtain an API key browse to http://steamcommunity.com/dev/apikey");
return;
}
string playerName = connection.username;
string steamID = Convert.ToString(connection.userid);
if (whitelist.Contains(steamID))
{
if (logToConsole)
{
Log($"{playerName} ({steamID}) is whitelisted, allowing the player to join.");
}
return;
}
string url = $"http://api.steampowered.com/IPlayerService/IsPlayingSharedGame/v0001/?key={APIKey}&steamid={steamID}&appid_playing=252490";
Interface.GetMod().GetLibrary <WebRequests>("WebRequests").EnqueueGet(url, (code, response) => IsFamilySharing(code, response, connection), this);
}
bool CanConnect(BanData bandata, Network.Connection connection, out string reason)
{
reason = string.Empty;
string ipaddress = connection.ipaddress.Substring(0, connection.ipaddress.IndexOf(":"));
string userid = connection.userid.ToString();
if (bandata.steamID == ipaddress)
{
string reason2 = bandata.reason;
int duration = bandata.expiration == 0 ? 0 : Convert.ToInt32(Time.time) - bandata.expiration;
UnbanIP(null, ipaddress);
BanID(null, connection.userid, reason2, duration);
bandata = banLogs[userid];
}
if (bandata.expiration != 0 && Convert.ToInt32(LogTime()) >= bandata.expiration)
{
Unban(null, userid);
}
else
{
if (!bandata.IPs.Contains(ipaddress))
{
AddIPToUserBan(userid, ipaddress);
}
if (banLogs[userid] == null)
{
BanID(null, connection.userid, bandata.reason, bandata.expiration == 0 ? 0 : Convert.ToInt32(Time.time) - bandata.expiration);
}
reason = bandata.expiration == 0 ? MessageDenyConnection : MessageDenyConnectionTemp;
return(false);
}
return(true);
}
public void StatusCode()
{
string testurl = "http://google.co.jp";
Network.Result result = new Network.Result();
Network.Connection con = new Network.Connection(testurl);
// 200 test
con.GetStatusCode(null, ref result);
Assert.AreSame(testurl, result.url);
Assert.IsTrue(result.data.Length > 0);
Assert.IsNull(result.header);
Assert.AreEqual(200, result.returnCode);
// 404 test
testurl += "/aaaa";
con.ChangeBaseURL(testurl);
con.GetStatusCode(null, ref result);
Assert.AreSame(testurl, result.url);
Assert.IsTrue(result.data.Length > 0);
Assert.IsNull(result.header);
Assert.AreEqual(404, result.returnCode);
// remote名解決エラー
testurl = "http://hogehoge"; // 存在しないドメインを指定する
con.ChangeBaseURL(testurl);
con.GetStatusCode(null, ref result);
Assert.AreSame(testurl, result.url);
Assert.IsTrue(result.data.Length > 0);
Assert.IsNull(result.header);
Assert.AreEqual(-1, result.returnCode);
}
void IsFamilySharing(int code, string response, Network.Connection connection)
{
string playerName = connection.username;
string steamID = Convert.ToString(connection.userid);
switch (code)
{
case 200:
var json = JsonConvert.DeserializeObject <WebResponse>(response);
if (json.Response.LenderSteamid != "0")
{
if (logToConsole)
{
Log($"{playerName} ({steamID}) is using a family shared account, kicking player...");
}
Network.Net.sv.Kick(connection, "Family shared accounts are not allowed.");
}
break;
case 401:
Log("Webrequest failed, invalid Steam API key.");
break;
case 404:
case 503:
Log("Webrequest failed. Steam API unavailable.");
break;
default:
Log($"Webrequest failed. Error code {code}.");
break;
}
}
object CanClientLogin(Network.Connection connection)
{
if (StripHtmlTags)
{
connection.username = StripTags(connection.username);
}
return(NameCheck(connection.username, connection.userid.ToString()));
}
void OnUserApprove(Network.Connection connection)
{
if (adminExcluded && IsAdmin(connection))
{
Puts($"{connection.username} is excluded from Twitch check");
return;
}
UserHasSteam(connection);
}
void OnUserApprove(Network.Connection connection)
{
string userid = connection.userid.ToString();
if (!permission.UserExists(userid))
{
OnPlayerFirstInit(connection.userid);
}
}
void OnPlayerSpawn(BasePlayer player, Network.Connection connection)
{
player.health = config.startingHealth;
player.metabolism.calories.value = config.startingCalories;
player.metabolism.hydration.value = config.startingHydration;
this.givePlayerStartingItems(player);
this.teachPlayerBlueprints(player);
}
void OnUserApprove(Network.Connection connection)
{
string userid = connection.userid.ToString();
ulong u = 0;
if (!permission.UserExists(userid) || !storedPlayersData.Players.Contains(connection.userid))
{
OnPlayerFirstInit(connection.userid);
}
}
void SendEchoConsole(Network.Connection cn, string msg)
{
if (Network.Net.sv.IsConnected())
{
Network.Net.sv.write.Start();
Network.Net.sv.write.PacketID(Network.Message.Type.ConsoleMessage);
Network.Net.sv.write.String(msg);
Network.Net.sv.write.Send(new Network.SendInfo(cn));
}
}
static void test_connection()
{
Debug.Log("test_connection");
var sender = new Network.Connection();
var receiver = new Network.Connection();
const int NumIterations = 256;
for (int i = 0; i < NumIterations; ++i)
{
Network.PacketHeader senderPacketHeader;
Network.PacketHeader receiverPacketHeader;
sender.GeneratePacketHeader(out senderPacketHeader);
receiver.GeneratePacketHeader(out receiverPacketHeader);
if ((i % 11) != 0)
{
sender.ProcessPacketHeader(ref receiverPacketHeader);
}
if ((i % 13) != 0)
{
receiver.ProcessPacketHeader(ref senderPacketHeader);
}
}
ushort[] senderAcks = new ushort[Network.Connection.MaximumAcks];
ushort[] receiverAcks = new ushort[Network.Connection.MaximumAcks];
int numSenderAcks = 0;
int numReceiverAcks = 0;
sender.GetAcks(ref senderAcks, ref numSenderAcks);
receiver.GetAcks(ref receiverAcks, ref numReceiverAcks);
Assert.IsTrue(numSenderAcks > NumIterations / 2);
Assert.IsTrue(numReceiverAcks > NumIterations / 2);
var senderAcked = new bool[NumIterations];
var receiverAcked = new bool[NumIterations];
for (int i = 0; i < NumIterations / 2; ++i)
{
senderAcked[senderAcks[i]] = true;
receiverAcked[receiverAcks[i]] = true;
}
for (int i = 0; i < NumIterations / 2; ++i)
{
Assert.IsTrue(senderAcked[i] == ((i % 13) != 0));
Assert.IsTrue(receiverAcked[i] == ((i % 11) != 0));
}
}
public PlutonUIEntity(Network.Connection con = null)
{
if (con != null)
{
connections = new List <Network.Connection>()
{
con
}
}
;
}
object CanBypassQueue(Network.Connection connection)
{
var ID = connection.userid.ToString();
if (connection.userid.IsSteamId() && !permission.UserHasPermission(ID, perm))
{
Puts($"{connection.username} ({connection.userid}) is skipping the queue because he/she is a new player");
LogToFile("connects", $"[{DateTime.Now}] {connection.username} ({connection.userid}) is skipping the queue because he/she is a new player", this, false);
return(true);
}
return(null);
}
void UserIsFollowingCallBack(int code, string response, Network.Connection connection)
{
if (code != 200)
{
Puts($"{connection.username} tried to log in but does not follow you on Twitch");
ConnectionAuth.Reject(connection, string.Format(lang.GetMessage("RejectMessage", this, connection.userid.ToString()), twitchAccount));
}
else
{
Puts($"{connection.username} is a follower. Allowing.");
}
}
object CanClientLogin(Network.Connection connection)
{
var curPlayers = BasePlayer.activePlayerList.Count;
var maxPlayers = ConVar.Server.maxplayers;
if ((curPlayers + ReservedSlots) >= maxPlayers && !HasPermission(connection.userid.ToString(), "reserved.slot"))
{
return(GetMessage("ReservedSlotsOnly", connection.userid.ToString()));
}
return(null);
}
/// <summary>
/// main proc
/// </summary>
public static int Main(string[] args)
{
Network.Result result = new Network.Result();
result.returnCode = retParameterIsNotEnough;
result.data = strParameterIsNotEnough;
if (args.Length >= 1)
{
Network.Connection con = new Network.Connection(args[0]);
con.GetStatusCode(null, ref result);
}
Console.WriteLine(result.data);
return result.returnCode;
}
//[ChatCommand("boffline")]
//private void cmdboffline(BasePlayer player, string command, string[] args)
//{
// this.lastOnline[player.userID].lastOnline = this.lastOnline[player.userID].lastOnline.Subtract(TimeSpan.FromHours(3));
//}
private string SendStatus(Network.Connection connection, string[] args)
{
if (connection.authLevel < 1)
{
return("You lack the permission to do that");
}
if (args.Length == 1)
{
BasePlayer target = FindPlayerByPartialName(args[0]);
if (target is BasePlayer && lastOnline.ContainsKey(target.userID))
{
LastOnline lo = lastOnline[target.userID];
StringBuilder sb = new StringBuilder();
if (IsOffline(target.userID))
{
sb.AppendLine("<color=red><size=15>AntiOfflineRaid Status</size></color>: " + target.displayName);
sb.AppendLine("<color=lightblue>Player Status</color>: <color=red>Offline</color>: " + lo.lastOnline.ToString());
}
else
{
sb.AppendLine("<color=lime><size=15>AntiOfflineRaid Status</size></color>: " + target.displayName);
sb.AppendLine("<color=lightblue>Player Status</color>: <color=lime>Online</color>");
}
sb.AppendLine("<color=lightblue>AFK</color>: " + lo.afkMinutes + " minutes");
if (clanShare)
{
sb.AppendLine("<color=lightblue>Clan Status</color>: " + (IsClanOffline(target.userID) ? "<color=red>Offline</color>" : "<color=lime>Online</color>") + " (" + this.getClanMembersOnline(target.userID) + ")");
}
float scale = scaleDamage(target.userID);
if (scale != -1)
{
sb.AppendLine("<color=lightblue>Scale</color>: " + scale);
}
return(sb.ToString());
}
else
{
return("No player found.");
}
}
else
{
return("Invalid Syntax. ao <PlayerName>");
}
}
private string CanClientLogin(Network.Connection connection)
{
if (permission.UserHasPermission(connection.userid.ToString(), Perm))
{
return(null);
}
if (Admin.ServerInfo().Queued >= Limit)
{
return(lang.GetMessage("KickMessage", this, connection.userid.ToString()));
}
return(null);
}
object CanBypassQueue(Network.Connection connection)
{
if (connection.authLevel > 0)
{
return(true);
}
var data = GetQueueData(connection.userid);
if (DateTime.Now.Subtract(data.disconnectTime).TotalSeconds < timeToHoldSpot * 60f)
{
return(true);
}
return(null);
}
void TestCommand(BasePlayer player, string command, string[] args)
{
string prefab = "assets/prefabs/player/player.prefab";
BasePlayer newPlayer = (BasePlayer)GameManager.server.CreateEntity(prefab, player.transform.position);
newPlayer.Spawn();
newPlayer.InitializeHealth(1000, 1000);
newPlayer.StartMaxHealth();
fakePlayers.Add(newPlayer);
Network.Connection connection = new Network.Connection();
connection.player = newPlayer;
connection.userid = newPlayer.userID;
connection.username = player.displayName;
newPlayer.PlayerInit(connection);
}
object CanClientLogin(Network.Connection connection)
{
string ondate;
if (bans.TryGetValue(connection.userid, out ondate))
{
if (Now().CompareTo(ParseTime(ondate)) > 0)
{
bans.Remove(connection.userid);
return(null);
}
return($"Вы забанены до {ondate}");
}
return(null);
}
void UserHasSteamConnectedCallBack(int code, string response, Network.Connection connection)
{
if (code != 200)
{
Puts($"{connection.username} tried to log in but does not have its Steam account connected to Twitch");
ConnectionAuth.Reject(connection, string.Format(lang.GetMessage("RejectMessage", this, connection.userid.ToString()), twitchAccount));
}
else
{
var user = JsonConvert.DeserializeObject <TwitchUser>(response);
if (!string.IsNullOrEmpty(user?.Name))
{
Puts($"{connection.username} connecting. Checking if is a follower.");
UserIsFollowing(user.Name, connection);
}
}
}
object CanClientLogin(Network.Connection connection)
{
if (deadPlayers.ContainsKey(connection.userid))
{
int remaining = (int)deadPlayers[connection.userid] - (int)GrabCurrentTime();
int time = remaining / 60;
string timeMsg = lang.GetMessage("minutes", this, connection.userid.ToString());
if (remaining <= 90)
{
time = remaining;
timeMsg = lang.GetMessage("seconds", this, connection.userid.ToString());
}
return(string.Format(lang.GetMessage("wait", this, connection.userid.ToString()), time, timeMsg));
}
return(null);
}
// Players hooks
object CanClientLogin(Network.Connection connection)
{
ulong userID = connection.userid;
if (m_configData.BannedPlayers.ContainsKey(userID))
{
string playerName = PlayerName(userID);
string message = m_configData.Messages["player_was_banned"];
message = message.Replace("%player_name", playerName);
message = message.Replace("%player_steamid", userID.ToString());
message = message.Replace("%reason", m_configData.BannedPlayers[userID].reason);
return(message);
}
return(true);
}
object CanClientLogin(Network.Connection connection)
{
var slotsPlayers = GetSlotPlayers();
bool isPrior = permission.UserHasPermission(connection.userid.ToString(), permissionPrior);
var checkResult = LoginSlotCheck(isPrior, slotsPlayers.PriorPlayers, slotsPlayers.StandardPlayers);
if (!checkResult.canLogin)
{
return(GetMessage(checkResult.messageCode, connection.userid.ToString()));
}
if (checkResult.needToKick != null)
{
foreach (var kickedPlayer in checkResult.needToKick)
{
PushOut(kickedPlayer);
}
}
return(null);
}
//Oxide Hook
void CanClientLogin(Network.Connection connection)
{
//Checks if the player has been verified before, if not -> verify player.
if (!verifiedPlayers.Contains(connection.userid.ToString()))
{
if (steamAPIKey != "insertAPIKeyHere")
{
string url = "http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=" + steamAPIKey + "&format=json&input_json={\"appids_filter\":[252490],\"steamid\":" + connection.userid + "}";
ConnectingPlayer connectingPlayer = new ConnectingPlayer(connection);
webRequests.EnqueueGet(url, (code, response) => connectingPlayer.connectionResponse = WebRequestCallback(code, response), this, null, 1.5f);
RespondOnWebRequest(connectingPlayer);
}
else
{
ConnectionAuth.Reject(connection, "MinimumPlaytime has no steamAPI key entered by the server owner yet.");
}
}
}
object CanClientLogin(Network.Connection connection)
{
string ipaddress = connection.ipaddress.Substring(0, connection.ipaddress.IndexOf(":"));
string userid = connection.userid.ToString();
string reason = string.Empty;
if (banLogs[userid] != null)
{
if (!CanConnect(banLogs[userid], connection, out reason))
{
return(reason);
}
}
if (bannedIPs[ipaddress] != null)
{
if (!CanConnect(bannedIPs[ipaddress], connection, out reason))
{
return(reason);
}
}
return(null);
}
