private void Anonymize(string id)
{
var steamId = new SteamId();
steamId.Value = Convert.ToUInt64(id);
SteamServer.UpdatePlayer(steamId, ANONYMIZED_NAME, 0);
}
public void Update()
{
server.Update();
SteamServer?.Update();
double ms = DateTime.UtcNow.Ticks / 10_000d;
if (ms >= nextSendTime)
{
nextSendTime = ms + 1000f / SharedConstants.UpdateRate;
if (Players.Count <= 0)
{
return;
}
Dictionary <int, PlayerMove> toSend = Players.Values.Where(plr => !plr.Spectating).ToDictionary(plr => plr.Id, plr => plr.Movement);
var writer = server.CreateMessage();
writer.Write(MessageType.MoveData);
writer.Write(toSend);
Broadcast(writer, NetDeliveryMethod.UnreliableSequenced, SharedConstants.MoveDataChannel);
}
}
public async Task Server(int delay = 100)
{
Print("Initializing Server");
//
// Init Server
//
var serverInit = new SteamServerInit("rust", "Rusty Mode")
{
GamePort = 28015,
Secure = true,
QueryPort = 28016
};
Steamworks.SteamServer.Init(252490, serverInit);
SteamServer.LogOnAnonymous();
Print("Server Initliazed");
await Task.Delay(1000);
await TestServerAuth(delay);
await Task.Delay(1000);
Print("Closing Server");
Steamworks.SteamServer.Shutdown();
}
public async Task SetupAsync()
{
ConfigureServices();
Logger logger = ServiceProvider.GetService <ILoggerProvider>()
.GetLogger("Server");
logger.LogInformation("Starting server");
ServerConfig config = ServiceProvider.GetService <IConfigProvider>().Config;
SteamServerInit init = new SteamServerInit
{
GamePort = config.Port,
Secure = true,
QueryPort = (ushort)(config.Port + 1),
SteamPort = (ushort)(config.Port + 2),
VersionString = "0.1",
DedicatedServer = true,
IpAddress = IPAddress.Parse(config.IpAddress),
ModDir = "pf",
GameDescription = "Pony Forest"
};
try
{
SteamServer.Init(1026040, init);
SteamServer.ServerName = config.Name;
SteamServer.AutomaticHeartbeats = true;
SteamServer.DedicatedServer = true;
SteamServer.Passworded = false;
SteamServer.MaxPlayers = config.MaxPlayers;
SteamServer.LogOnAnonymous();
NetAddress address = NetAddress.From(config.IpAddress, config.Port);
_serverCore = SteamNetworkingSockets.CreateNormalSocket <ServerCore>(address);
}
catch (Exception e)
{
logger.LogFailure($"Can't start server: {Environment.NewLine + e}");
}
try
{
IMessageRouter messageRouter = ServiceProvider.GetService <IMessageRouter>();
logger.LogInformation("Server started");
_serverCore.OnMessageReceived = messageRouter.Route;
IMessageListener messageListener = ServiceProvider.GetService <IMessageListener>();
await messageListener.StartListening(_serverCore);
}
catch (Exception e)
{
logger.LogFailure($"Error while running server: {Environment.NewLine + e}");
}
}
public override void HandlePacket(ref NetworkPacket Packet, ref SteamClient Client)
{
redBuffer Buffer = new redBuffer();
// We send the length first.
Client.UpdateFriendslist();
Buffer.WriteUInt32((UInt32)Client.FriendsList.Count);
foreach (SteamFriend Friend in Client.FriendsList)
{
Buffer.WriteUInt32((UInt32)Friend.Status);
Buffer.WriteBlob(Friend.Username);
Buffer.WriteUInt64(Friend.XUID);
}
Packet.CreatePacket(Packet._TransactionID, 200, Buffer, Client);
// Clear the buffer.
Buffer = new redBuffer();
// Serialize the packet.
Packet.Serialize(ref Buffer, Client);
// Send the response.
SteamServer.Send(Client.ClientID, Buffer.GetBuffer());
}
public void ShutdownServer()
{
//foreach(Connection conn in steamworksServerManager.Connected)
//{
// conn.Close();
//}
//steamworksServerManager.Close();
//steamworksServerManager = null;
//steamSocket = null;
doCallbacks = false;
foreach (ulong steamID in connectedSteamIDs)
{
SteamUser.EndAuthSession(steamID);
SteamServer.EndSession(steamID);
}
connectedSteamIDs = new List <ulong>();
SteamServer.Shutdown();
if (NetTools.ENSManagingSteam())
{
//SteamServer.LogOff();
if ((NetTools.isServer && NetServer.serverInstance.steamAppID != -1) || (NetTools.isClient && NetClient.instanceClient.steamAppID != -1))
{
//SteamServer.Shutdown();
//SteamClient.Shutdown();
}
}
serverRunning = false;
}
void Start()
{
DontDestroyOnLoad(this);
SteamServerInit serverInit = new SteamServerInit("gmod", "Garry Mode")
{
GamePort = 28015,
Secure = true,
QueryPort = 28016,
DedicatedServer = false
};
try
{
SteamServer.Init(480, serverInit);
}
catch (System.Exception e)
{
Debug.Log(e);
}
SteamServer.OnSteamServersConnected += () =>
{
Debug.Log("Connected");
};
}
protected override void _Start()
{
SteamServer.OnValidateAuthTicketResponse += SteamServer_OnValidateAuthTicketResponse;
var init = new SteamServerInit("fragsurf", "Fragsurf");
init.GamePort = (ushort)GameServer.Instance.Socket.GameplayPort;
init.QueryPort = (ushort)SteamQueryPort;
init.SteamPort = (ushort)SteamPort;
init.VersionString = Structure.Version;
try
{
SteamServer.Init(Structure.AppId, init);
SteamServer.ServerName = GameServer.Instance.Socket.ServerName ?? DefaultServerName;
SteamServer.DedicatedServer = true;
SteamServer.Passworded = !string.IsNullOrEmpty(GameServer.Instance.Socket.ServerPassword);
SteamServer.MaxPlayers = GameServer.Instance.Socket.MaxPlayers;
SteamServer.AutomaticHeartbeats = true;
SteamServer.LogOnAnonymous();
DevConsole.WriteLine($"Steamworks Server initialized\n - Name: {SteamServer.ServerName}\n - Password: {GameServer.Instance.Socket.ServerPassword}\n - Version: {init.VersionString}\n - Game Port: {init.GamePort} (This must be open to allow players to connect)\n - Query Port: {init.QueryPort} (This must be open to show on master server list)\n - Steam Port: {init.SteamPort} (This must be open to show on master server list)");
GameObject.FindObjectOfType <ServerConsole>()?.SetTitle(GameServer.Instance.Socket.ServerName);
}
catch (Exception e)
{
Debug.LogError(e.ToString());
}
}
private void CloseConnection()
{
if (this.persistance != null)
{
this.persistance.Dispose();
this.persistance = null;
}
EACServer.DoShutdown();
Network.Net.sv.callbackHandler = null;
using (TimeWarning timeWarning = TimeWarning.New("sv.Stop", 0.1f))
{
Network.Net.sv.Stop("Shutting Down");
}
using (timeWarning = TimeWarning.New("RCon.Shutdown", 0.1f))
{
RCon.Shutdown();
}
using (timeWarning = TimeWarning.New("Steamworks.GameServer.Shutdown", 0.1f))
{
if (SteamServer.IsValid)
{
UnityEngine.Debug.Log("Steamworks Shutting Down");
SteamServer.Shutdown();
UnityEngine.Debug.Log("Okay");
}
}
}
private void Initialize(ushort gamePort, ushort steamPort, ushort queryPort, string serverName, int maxPlayers)
{
SteamServerInit init = new SteamServerInit("Conquest", "Conquest")
{
GamePort = gamePort,
SteamPort = steamPort,
QueryPort = queryPort,
VersionString = "1.0",
Secure = true
};
try
{
SteamServer.Init(923440, init);
}
catch (Exception e)
{
logger.LogWarning(e.Message);
}
SteamServer.ServerName = serverName;
SteamServer.MaxPlayers = maxPlayers;
SteamServer.Passworded = false;
SteamServer.DedicatedServer = true;
SteamServer.LogOnAnonymous();
if (logger.LogEnabled())
{
logger.Log("Logged on as Anonymous");
}
}
/// <summary>
/// Start Steam game server
/// </summary>
/// <param name="onFail"></param>
internal static void StartServer(Action onFail)
{
SteamServerInit serverInit = new("Team-Capture", "Team-Capture")
{
DedicatedServer = true,
Secure = true,
VersionString = Application.version,
IpAddress = IPAddress.Any,
GamePort = 7777
};
authResults = new Dictionary <SteamUser, AuthResult>();
SteamServer.OnSteamServersConnected += () => Logger.Info("Server has connected to Steam game servers.");
SteamServer.OnSteamServerConnectFailure += (result, retry) => OnSteamConnectFail(result, onFail);
SteamServer.OnValidateAuthTicketResponse += OnAuthResponse;
try
{
SteamServer.Init(SteamManager.Instance.SteamSettings.appDedicatedServerId, serverInit);
SteamServer.LogOnAnonymous();
IsOnline = true;
}
catch (Exception ex)
{
Logger.Error(ex, "Something went wrong while starting the steam game server integration!");
IsOnline = false;
onFail.Invoke();
}
}
public override void HandlePacket(ref NetworkPacket Packet, ref SteamClient Client)
{
Byte[] Username = new Byte[1];
Byte[] Reserved1 = new Byte[1];
Byte[] Reserved2 = new Byte[1];
Byte[] Reserved3 = new Byte[1];
Byte[] Reserved4 = new Byte[1];
Byte[] WindowsName = new Byte[1];
redBuffer Buffer;
// Read the boring info.
Buffer = new redBuffer(Packet._Data);
Buffer.ReadBlob(ref Username);
Buffer.ReadBlob(ref Reserved1);
Buffer.ReadBlob(ref Reserved2);
Buffer.ReadBlob(ref Reserved3);
Buffer.ReadBlob(ref Reserved4);
Buffer.ReadBlob(ref WindowsName);
// Set the client info.
if (SteamServer.Anonymous)
{
Client.Username = Username;
Client.XUID = (UInt64)0x110000110000000;
Client.XUID += Client.ClientID;
Client.SessionID = Client.ClientID;
Client.isAuthenticated = true;
}
else
{
// Reserved.
}
// Clear the buffer.
Buffer = new redBuffer();
// Return the info.
Buffer.WriteBlob(Client.Username);
Buffer.WriteUInt64(0); // Reserved.
Buffer.WriteUInt32(Client.SessionID);
if (Client.isAuthenticated == true)
{
Packet.CreatePacket(Packet._TransactionID, 200, Buffer, Client);
}
else
{
Packet.CreatePacket(Packet._TransactionID, 404, Buffer, Client);
}
// Clear the buffer.
Buffer = new redBuffer();
// Serialize the packet.
Packet.Serialize(ref Buffer, Client);
// Send the response.
SteamServer.Send(Client.ClientID, Buffer.GetBuffer());
}
public void OnAuthRequestMessage(NetworkConnection conn, AuthRequestMessage msg)
{
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Begin Authentication Session: {0}", msg.steamId);
}
SteamServer.BeginAuthSession(msg.ticket, msg.steamId);
}
private static void OnSteamConnectFail(Result result, Action onFail)
{
Logger.Error("Failed to connect to Steam game servers! Result: {Result}", result);
SteamServer.LogOff();
//ShutdownServer();
onFail.Invoke();
}
/// <summary>
/// Runs Steam game server callbacks
/// </summary>
internal static void RunCallbacks()
{
if (!IsOnline)
{
return;
}
SteamServer.RunCallbacks();
}
/// <summary>
/// Begins <see cref="SteamServer.BeginAuthSession" /> on the <see cref="SteamUser" />
/// </summary>
/// <param name="user">The user to auth</param>
/// <param name="onSuccess">Invoked if auth is a success</param>
/// <param name="onFail">Invoked if auth was a fail</param>
public static void BeginAuthUser(SteamUser user, Action onSuccess, Action onFail)
{
Logger.Info("Begin client {ID} auth session...", user.UserId);
authResults.Add(user, new AuthResult
{
OnSuccess = onSuccess,
OnFail = onFail
});
SteamServer.BeginAuthSession(user.AuthTicket.Data, user.UserId);
}
protected override void _Update()
{
if (SteamServer.IsValid)
{
SteamServer.RunCallbacks();
}
Application.targetFrameRate = Game.PlayerManager.PlayerCount > 0
? _minFps ? (int)(1 / Time.fixedDeltaTime) + 5 : TimeStep.Instance.TargetFPS
: 10;
}
private void StartSteamServer()
{
if (SteamServer.IsValid)
{
return;
}
IPAddress pAddress = null;
if (!string.IsNullOrEmpty(ConVar.Server.ip))
{
pAddress = IPAddress.Parse(ConVar.Server.ip);
}
SteamServerInit steamServerInit = new SteamServerInit("rust", "Rust")
{
IpAddress = pAddress,
GamePort = (ushort)Network.Net.sv.port,
Secure = ConVar.Server.secure,
VersionString = 2177.ToString()
};
if (!this.useQueryPort)
{
steamServerInit = steamServerInit.WithQueryShareGamePort();
}
else
{
steamServerInit.QueryPort = (ushort)ConVar.Server.queryport;
}
SteamServer.OnCallbackException = (Exception e) => {
UnityEngine.Debug.LogError(e.Message);
UnityEngine.Debug.LogError(e.StackTrace);
};
try
{
SteamServer.Init(Rust.Defines.appID, steamServerInit);
}
catch (Exception exception1)
{
Exception exception = exception1;
UnityEngine.Debug.LogWarning(string.Concat("Couldn't initialize Steam Server (", exception.Message, ")"));
UnityEngine.Application.Quit();
return;
}
SteamServer.OnValidateAuthTicketResponse += new Action <SteamId, SteamId, AuthResponse>(this.OnValidateAuthTicketResponse);
SteamServer.OnSteamServerConnectFailure += new Action <Result, bool>(this.OnSteamConnectionFailure);
SteamServer.OnSteamServersDisconnected += new Action <Result>(this.OnSteamServersDisconnected);
SteamServer.OnSteamServersConnected += new Action(this.OnSteamConnected);
Steamworks.SteamInventory.OnDefinitionsUpdated += new Action(this.OnInventoryDefinitionsUpdated);
SteamServer.DedicatedServer = true;
SteamServer.LogOnAnonymous();
base.InvokeRepeating("UpdateServerInformation", 2f, 30f);
base.InvokeRepeating("UpdateItemDefinitions", 10f, 3600f);
DebugEx.Log("SteamServer Initialized", StackTraceLogType.None);
}
protected override void OnPlayerDisconnected(IPlayer player)
{
if (player.IsFake)
{
SteamServer.BotCount--;
}
else
{
SteamServer.EndSession(player.SteamId);
}
}
/// <summary>
/// Shutdown Steam game server
/// </summary>
internal static void ShutdownServer()
{
if (!IsOnline)
{
return;
}
Logger.Info("Shutting down connection for Steam game server...");
SteamServer.LogOff();
SteamServer.Shutdown();
IsOnline = false;
}
public void Anonymize(IPlayer player)
{
AnonymizedPlayer anonymizedPlayer;
if (!AnonymizedPlayers.TryGetValue(player.Id, out anonymizedPlayer))
{
anonymizedPlayer = new AnonymizedPlayer(player, GenerateRandomName.Invoke());
}
SteamServer.UpdatePlayer(anonymizedPlayer.SteamID, anonymizedPlayer.AnonymizedName, 0);
AnonymizedPlayers.Add(player.Id, anonymizedPlayer);
}
public static IEnumerator Run(Connection connection)
{
connection.authStatus = "";
if (!SteamServer.BeginAuthSession(connection.token, connection.userid))
{
ConnectionAuth.Reject(connection, "Steam Auth Failed");
yield break;
}
Auth_Steam.waitingList.Add(connection);
Stopwatch stopwatch = Stopwatch.StartNew();
while (stopwatch.Elapsed.TotalSeconds < 30 && connection.active && !(connection.authStatus != ""))
{
yield return(null);
}
Auth_Steam.waitingList.Remove(connection);
if (!connection.active)
{
yield break;
}
if (connection.authStatus.Length == 0)
{
ConnectionAuth.Reject(connection, "Steam Auth Timeout");
SteamServer.EndSession(connection.userid);
yield break;
}
if (connection.authStatus == "banned")
{
ConnectionAuth.Reject(connection, string.Concat("Auth: ", connection.authStatus));
SteamServer.EndSession(connection.userid);
yield break;
}
if (connection.authStatus == "gamebanned")
{
ConnectionAuth.Reject(connection, string.Concat("Steam Auth: ", connection.authStatus));
SteamServer.EndSession(connection.userid);
yield break;
}
if (connection.authStatus == "vacbanned")
{
ConnectionAuth.Reject(connection, string.Concat("Steam Auth: ", connection.authStatus));
SteamServer.EndSession(connection.userid);
yield break;
}
if (connection.authStatus == "ok")
{
SteamServer.UpdatePlayer(connection.userid, connection.username, 0);
yield break;
}
ConnectionAuth.Reject(connection, string.Concat("Steam Auth Error: ", connection.authStatus));
SteamServer.EndSession(connection.userid);
}
protected override void _Destroy()
{
try
{
SteamServer.Shutdown();
}
catch
{
// whatever
}
SteamServer.OnValidateAuthTicketResponse -= SteamServer_OnValidateAuthTicketResponse;
}
public void OnDisconnected(string strReason, Network.Connection connection)
{
this.connectionQueue.RemoveConnection(connection);
ConnectionAuth.OnDisconnect(connection);
SteamServer.EndSession(connection.userid);
EACServer.OnLeaveGame(connection);
BasePlayer basePlayer = connection.player as BasePlayer;
if (basePlayer)
{
Interface.CallHook("OnPlayerDisconnected", basePlayer, strReason);
basePlayer.OnDisconnected();
}
}
public override void ServerStop()
{
if (Server != null)
{
for (int i = 0; i < Server.Connected.Count; i++)
{
Server.Connected[i].Flush();
Server.Connected[i].Close();
}
Server.Close();
SteamServer.Shutdown();
Server = null;
}
}
private void StartDedicatedServer()
{
SteamServer.OnSteamServersConnected += OnSteamServerConnected;
// Load server config params from the batch file execution
LoadCommandLineArgs();
// Initialize the steam server
CreateSteamServer();
SteamServer.LogOnAnonymous();
}
private void SteamQueryResponse()
{
OutgoingPacket outgoingPacket;
if (!SteamServer.IsValid)
{
return;
}
using (TimeWarning timeWarning = TimeWarning.New("SteamGameServer.GetNextOutgoingPacket", 0.1f))
{
while (SteamServer.GetOutgoingPacket(out outgoingPacket))
{
Network.Net.sv.SendUnconnected(outgoingPacket.Address, outgoingPacket.Port, outgoingPacket.Data, outgoingPacket.Size);
}
}
}
private void DoTick()
{
if (SteamServer.IsValid)
{
Interface.CallHook("OnTick");
SteamServer.RunCallbacks();
}
RCon.Update();
for (int i = 0; i < Network.Net.sv.connections.Count; i++)
{
Network.Connection item = Network.Net.sv.connections[i];
if (!item.isAuthenticated && item.GetSecondsConnected() >= (float)ConVar.Server.authtimeout)
{
Network.Net.sv.Kick(item, "Authentication Timed Out");
}
}
}
private void SteamServer_OnValidateAuthTicketResponse(SteamId steamid, SteamId owner, AuthResponse response)
{
var player = Game.PlayerManager.FindPlayer(steamid);
if (player == null)
{
return;
}
if (response != AuthResponse.OK)
{
GameServer.Instance.Socket.DisconnectPlayer(player.ClientIndex, DenyReason.SteamAuthFailed.ToString());
}
else
{
SteamServer.UpdatePlayer(steamid, player.DisplayName, 0);
}
}
protected override void OnPlayerIntroduced(IPlayer player)
{
if (player.IsFake)
{
SteamServer.BotCount++;
}
else
{
var sp = player as ServerPlayer;
if (sp.TicketData != null &&
sp.TicketData.Length > 0 &&
!Game.IsLocalServer &&
!SteamServer.BeginAuthSession(sp.TicketData, sp.SteamId))
{
((GameServer)Game).Socket.DisconnectPlayer(sp, DenyReason.SteamAuthFailed.ToString());
}
}
}
