internal static bool CheckValid(ValidateAuthTicketResponse_t r)
{
ESteamRejection?reason = null;
if (OnJoinRequested != null)
{
foreach (var handler in OnJoinRequested.GetInvocationList().Cast <JoinRequested>())
{
try
{
handler(r.m_SteamID, ref reason);
if (reason != null)
{
Provider.Reject(r.m_SteamID, reason.Value);
return(false);
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
}
return(true);
}
private void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pResponse)
{
Debug.Log("OnValidateAuthTicketResponse Called steamID: " + pResponse.m_SteamID);
if (pResponse.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseOK)
{
}
}
private void OnCheckValid(ValidateAuthTicketResponse_t callback, ref bool isValid)
{
var pendingPlayer = Provider.pending.FirstOrDefault(c => c.playerID.steamID.Equals(callback.m_SteamID));
if (pendingPlayer == null)
{
return;
}
PreConnectUnturnedPlayer player = new PreConnectUnturnedPlayer(container, pendingPlayer, playerManager);
UnturnedPlayerPreConnectEvent @event = new UnturnedPlayerPreConnectEvent(player, callback);
eventManager.Emit(this, @event);
if (@event.UnturnedRejectionReason != null)
{
Provider.reject(callback.m_SteamID, @event.UnturnedRejectionReason.Value);
isValid = false;
return;
}
if (@event.IsCancelled)
{
Provider.reject(callback.m_SteamID, ESteamRejection.PLUGIN);
isValid = false;
return;
}
isValid = true;
}
private void OnCheckValid(ValidateAuthTicketResponse_t callback, ref bool isValid)
{
if (isValid)
{
isValid = UnturnedPermissions.CheckValid(callback);
}
}
public static void Prefix(ValidateAuthTicketResponse_t callback)
{
foreach (SteamPending pendingPlayer in Provider.pending)
{
pendingPlayer.skinItems = new int[0];
pendingPlayer.packageSkins = new ulong[0];
pendingPlayer.packageHat = 0UL;
pendingPlayer.hatItem = 0;
pendingPlayer.maskItem = 0;
pendingPlayer.packageMask = 0UL;
pendingPlayer.packageGlasses = 0UL;
pendingPlayer.glassesItem = 0;
pendingPlayer.shirtItem = 0;
pendingPlayer.packageShirt = 0UL;
pendingPlayer.vestItem = 0;
pendingPlayer.packageVest = 0UL;
pendingPlayer.packageBackpack = 0UL;
pendingPlayer.backpackItem = 0;
pendingPlayer.pantsItem = 0;
pendingPlayer.packagePants = 0UL;
}
}
internal static void CheckValid(ValidateAuthTicketResponse_t r, ref bool isValid, ref string explain)
{
if (!isValid)
{
return;
}
ESteamRejection?reason = null;
try
{
var playerGroups = R.Permissions.GetGroups(new RocketPlayer(r.m_SteamID.ToString()), true);
string prefix = playerGroups.FirstOrDefault(x => !string.IsNullOrEmpty(x.Prefix))?.Prefix;
string suffix = playerGroups.FirstOrDefault(x => !string.IsNullOrEmpty(x.Suffix))?.Suffix;
if (prefix != null || suffix != null)
{
SteamPending steamPending = Provider.pending.FirstOrDefault(x => x.playerID.steamID == r.m_SteamID);
if (steamPending != null)
{
if (prefix != null && !steamPending.playerID.characterName.StartsWith(prefix))
{
steamPending.playerID.characterName = $"{prefix}{steamPending.playerID.characterName}";
}
if (suffix != null && !steamPending.playerID.characterName.EndsWith(suffix))
{
steamPending.playerID.characterName = $"{steamPending.playerID.characterName}{suffix}";
}
}
}
}
catch (Exception ex)
{
Core.Logging.Logger.Log($"Failed adding prefix/suffix to player {r.m_SteamID}: {ex}");
}
if (OnJoinRequested != null)
{
foreach (var handler in OnJoinRequested.GetInvocationList())
{
try
{
((JoinRequested)handler)(r.m_SteamID, ref reason);
if (reason != null)
{
Provider.reject(r.m_SteamID, reason.Value);
isValid = false;
return;
}
}
catch (Exception ex)
{
Core.Logging.Logger.LogException(ex);
}
}
}
return;
}
protected virtual void OnPendingPlayerConnecting(ValidateAuthTicketResponse_t callback, ref bool isValid, ref string explanation)
{
if (m_PendingUsers.Any(d => d.SteamId == callback.m_SteamID))
{
return;
}
if (!isValid)
{
return;
}
//todo check if it is working, if not this should be patched
var isPendingValid = isValid;
var rejectExplanation = explanation;
AsyncHelper.RunSync(async() =>
{
var steamPending = Provider.pending.FirstOrDefault(d => d.playerID.steamID == callback.m_SteamID);
if (steamPending == null)
{
return;
}
var pendingUser = new UnturnedPendingUser(this, m_UserDataStore, steamPending);
var userData = await m_UserDataStore.GetUserDataAsync(pendingUser.Id, pendingUser.Type);
if (userData != null)
{
userData.LastSeen = DateTime.Now;
userData.LastDisplayName = pendingUser.DisplayName;
await m_UserDataStore.SetUserDataAsync(userData);
}
else
{
await m_DataSeeder.SeedUserDataAsync(pendingUser.Id, pendingUser.Type, pendingUser.DisplayName);
await m_EventBus.EmitAsync(m_Runtime, this, new UserFirstConnectEvent(pendingUser));
}
m_PendingUsers.Add(pendingUser);
var userConnectingEvent = new UserConnectEvent(pendingUser);
await m_EventBus.EmitAsync(m_Runtime, this, userConnectingEvent);
if (!string.IsNullOrEmpty(userConnectingEvent.RejectionReason))
{
isPendingValid = false;
rejectExplanation = userConnectingEvent.RejectionReason;
}
if (userConnectingEvent.IsCancelled)
{
isPendingValid = false;
}
});
isValid = isPendingValid;
explanation = rejectExplanation;
}
private void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t callback)
{
Identity ident = (SteamIdentity)callback.m_SteamID;
if (callback.m_eAuthSessionResponse != EAuthSessionResponse.k_EAuthSessionResponseOK)
{
if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseUserNotConnectedToSteam)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_NO_STEAM);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseNoLicenseOrExpired)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_LICENSE_EXPIRED);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseVACBanned)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_VAC_BAN);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseLoggedInElseWhere)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_ELSEWHERE);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseVACCheckTimedOut)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_TIMED_OUT);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseAuthTicketCanceled)
{
((ServerConnection)Connection).DisconnectClient(ident);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_USED);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseAuthTicketInvalid)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_NO_USER);
}
else if (callback.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponsePublisherIssuedBan)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.AUTH_PUB_BAN);
}
return;
}
PendingUser pending = ((ServerConnection)Connection).PendingPlayers.FirstOrDefault(pendingPlayer => pendingPlayer.Identity == ident);
if (pending == null)
{
((ServerConnection)Connection).Reject(ident, ERejectionReason.NOT_PENDING);
return;
}
pending.HasAuthentication = true;
((ServerConnection)Connection).Accept(pending);
}
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pResponse)
{
print(pResponse.m_SteamID);
if (pResponse.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseOK)
{
}
else
{
}
}
internal static bool CheckValid(ValidateAuthTicketResponse_t r)
{
ESteamRejection?reason = null;
try
{
IOrderedEnumerable <RocketPermissionsGroup> playerGroups =
R.Permissions.GetGroups(new RocketPlayer(r.m_SteamID.ToString()), true).OrderBy(x => x.Priority);
string prefix = playerGroups.FirstOrDefault(x => x.Prefix != null)?.Prefix ?? "";
string suffix = playerGroups.FirstOrDefault(x => x.Suffix != null)?.Suffix ?? "";
if (prefix != "" || suffix != "")
{
SteamPending steamPending = Provider.pending.FirstOrDefault(x => x.playerID.steamID == r.m_SteamID);
if (steamPending != null)
{
if (prefix != "" && !steamPending.playerID.characterName.StartsWith(prefix))
{
steamPending.playerID.characterName = $"{prefix}{steamPending.playerID.characterName}";
}
if (suffix != "" && !steamPending.playerID.characterName.EndsWith(suffix))
{
steamPending.playerID.characterName = $"{steamPending.playerID.characterName}{suffix}";
}
}
}
}
catch (Exception ex)
{
Core.Logging.Logger.Log($"Failed adding prefix/suffix to player {r.m_SteamID}: {ex}");
}
if (OnJoinRequested != null)
{
foreach (var handler in OnJoinRequested.GetInvocationList().Cast <JoinRequested>())
{
try
{
handler(r.m_SteamID, ref reason);
if (reason != null)
{
Provider.reject(r.m_SteamID, reason.Value);
return(false);
}
}
catch (Exception ex)
{
Core.Logging.Logger.LogException(ex);
}
}
}
return(true);
}
internal static bool CheckValid(ValidateAuthTicketResponse_t r)
{
ESteamRejection?reason = null;
try
{
RocketPermissionsGroup g = R.Permissions.GetGroups(new Rocket.API.RocketPlayer(r.m_SteamID.ToString()), true).FirstOrDefault();
if (g != null)
{
SteamPending steamPending = Provider.pending.FirstOrDefault(x => x.playerID.steamID == r.m_SteamID);
if (steamPending != null)
{
string prefix = g.Prefix ?? "";
string suffix = g.Suffix ?? "";
if (prefix != "" && !steamPending.playerID.characterName.StartsWith(g.Prefix))
{
steamPending.playerID.characterName = prefix + steamPending.playerID.characterName;
}
if (suffix != "" && !steamPending.playerID.characterName.EndsWith(g.Suffix))
{
steamPending.playerID.characterName = steamPending.playerID.characterName + suffix;
}
}
}
}
catch (Exception ex)
{
Core.Logging.Logger.Log("Failed adding prefix/suffix to player " + r.m_SteamID + ": " + ex.ToString());
}
if (OnJoinRequested != null)
{
foreach (var handler in OnJoinRequested.GetInvocationList().Cast <JoinRequested>())
{
try
{
handler(r.m_SteamID, ref reason);
if (reason != null)
{
Provider.reject(r.m_SteamID, reason.Value);
return(false);
}
}
catch (Exception ex)
{
Core.Logging.Logger.LogException(ex);
}
}
}
return(true);
}
protected virtual void OnPendingPlayerConnected(ValidateAuthTicketResponse_t callback, ref bool isvalid, ref string explanation)
{
var isvalid_ = isvalid;
var explanation_ = explanation;
AsyncHelper.RunSync(async() =>
{
if (!isvalid_)
{
return;
}
var steamPending = Provider.pending.First(d => d.playerID.steamID == callback.m_SteamID);
var pendingUser = new UnturnedPendingUser(steamPending);
await m_DataSeeder.SeedUserDataAsync(pendingUser.Id, pendingUser.Type, pendingUser.DisplayName);
var userData = await m_UserDataStore.GetUserDataAsync(pendingUser.Type, pendingUser.Id);
userData.LastSeen = DateTime.Now;
userData.LastDisplayName = pendingUser.DisplayName;
await m_UserDataStore.SaveUserDataAsync(userData);
pendingUser.PersistentData = userData.Data;
m_PendingUsers.Add(pendingUser);
var userConnectingEvent = new UserConnectingEvent(pendingUser);
await m_EventBus.EmitAsync(m_Runtime, this, userConnectingEvent);
if (!string.IsNullOrEmpty(userConnectingEvent.RejectionReason))
{
isvalid_ = false;
explanation_ = userConnectingEvent.RejectionReason;
}
if (userConnectingEvent.IsCancelled)
{
isvalid_ = false;
}
});
isvalid = isvalid_;
explanation = explanation_;
}
private static void HandleValidateAuthTicketResponse(ValidateAuthTicketResponse_t param)
{
if (ActiveSessions != null && ActiveSessions.Any(p => p.User == param.m_SteamID))
{
var session = ActiveSessions.First(p => p.User == param.m_SteamID);
session.Responce = param.m_eAuthSessionResponse;
session.GameOwner = param.m_OwnerSteamID;
Debug.Log("Processing session request data for " + param.m_SteamID.m_SteamID.ToString() + " status = " + param.m_eAuthSessionResponse);
if (session.OnStartCallback != null)
{
session.OnStartCallback.Invoke(session);
}
}
else
{
Debug.LogWarning("Recieved an authentication ticket responce for user " + param.m_SteamID.m_SteamID + " no matching session was found for this user.");
}
}
//-----------------------------------------------------------------------------
// Purpose: Tells us Steam3 (VAC and newer license checking) has accepted the user connection
//-----------------------------------------------------------------------------
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pResponse)
{
Debug.Log("OnValidateAuthTicketResponse Called steamID: " + pResponse.m_SteamID); // Riley
if (pResponse.m_eAuthSessionResponse == EAuthSessionResponse.k_EAuthSessionResponseOK)
{
// This is the final approval, and means we should let the client play (find the pending auth by steamid)
/* TODO Riley: Disabled
* for (uint i = 0; i < MAX_PLAYERS_PER_SERVER; ++i) {
* if (!m_rgPendingClientData[i].m_bActive)
* continue;
* else if (m_rgPendingClientData[i].m_SteamIDUser == pResponse.m_SteamID) {
* Debug.Log("Auth completed for a client");
* OnAuthCompleted(true, i);
* return;
* }
* }
*/
}
else
{
// Looks like we shouldn't let this user play, kick them
/* TODO Riley: Disabled
* for (uint i = 0; i < MAX_PLAYERS_PER_SERVER; ++i) {
* if (!m_rgPendingClientData[i].m_bActive)
* continue;
* else if (m_rgPendingClientData[i].m_SteamIDUser == pResponse.m_SteamID) {
* Debug.Log("Auth failed for a client");
* OnAuthCompleted(false, i);
* return;
* }
* }
*/
}
}
protected virtual void OnPendingPlayerConnecting(ValidateAuthTicketResponse_t callback, ref bool isValid,
ref string?explanation)
{
var user = GetUser(callback.m_SteamID);
if (user != null || m_PendingUsers.Any(d => d.SteamId == callback.m_SteamID))
{
return;
}
var steamPending = Provider.pending.FirstOrDefault(d => d.playerID.steamID == callback.m_SteamID);
if (steamPending == null)
{
return;
}
var pendingUser = new UnturnedPendingUser(this, m_UserDataStore, steamPending);
m_PendingUsers.Add(pendingUser);
var isPendingValid = isValid;
var rejectExplanation = explanation;
AsyncHelper.RunSync(async() =>
{
UnturnedUserConnectingEvent userEvent;
var userData = await m_UserDataStore.GetUserDataAsync(pendingUser.Id, pendingUser.Type);
if (userData != null)
{
userEvent = new UnturnedUserConnectingEvent(pendingUser);
userData.LastSeen = DateTime.Now;
userData.LastDisplayName = pendingUser.DisplayName;
UniTask.RunOnThreadPool(() => m_UserDataStore.SetUserDataAsync(userData)).Forget();
}
else
{
userEvent = new UnturnedUserFirstConnectingEvent(pendingUser);
UniTask.RunOnThreadPool(() => m_DataSeeder.SeedUserDataAsync(pendingUser.Id, pendingUser.Type, pendingUser.DisplayName)).Forget();
}
userEvent.IsCancelled = !isPendingValid;
if (rejectExplanation != null)
{
await userEvent.RejectAsync(rejectExplanation);
}
await m_EventBus.EmitAsync(m_Runtime, this, userEvent);
if (!string.IsNullOrEmpty(userEvent.RejectionReason))
{
isPendingValid = false;
rejectExplanation = userEvent.RejectionReason;
}
else if (userEvent.IsCancelled)
{
isPendingValid = false;
}
});
isValid = isPendingValid;
explanation = rejectExplanation;
}
public static bool CheckValid(ValidateAuthTicketResponse_t r)
{
return(UnturnedPermissions.CheckValid(r));
}
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pCallback)
{
Debug.Log("[" + ValidateAuthTicketResponse_t.k_iCallback + " - ValidateAuthTicketResponse] - " + pCallback.m_SteamID + " -- " + pCallback.m_eAuthSessionResponse + " -- " + pCallback.m_OwnerSteamID);
}
public UnturnedPlayerPreConnectEvent(PreConnectUnturnedPlayer player, ValidateAuthTicketResponse_t steamworksAuthResponse, bool global = true) : base(player, global)
{
SteamworksAuthResponse = steamworksAuthResponse;
PendingPlayer = player.PendingPlayer;
}
public UnturnedPlayerPreConnectEvent(PreConnectUnturnedPlayer player, ValidateAuthTicketResponse_t steamworksAuthResponse, string name = null, EventExecutionTargetContext executionTarget = EventExecutionTargetContext.Sync, bool global = true) : base(player, name, executionTarget, global)
{
SteamworksAuthResponse = steamworksAuthResponse;
PendingPlayer = player.PendingPlayer;
}
void OnValidateAuthTicketResponse(ValidateAuthTicketResponse_t pCallback)
{
Console.WriteLine("[" + ValidateAuthTicketResponse_t.k_iCallback + " - ValidateAuthTicketResponse] - " + pCallback.m_SteamID + " -- " + pCallback.m_eAuthSessionResponse + " -- " + pCallback.m_OwnerSteamID);
//TODO: Update data in Yargis here<<<<<<<<<
}
