private void OnP2PSessionConnectFail(P2PSessionConnectFail_t callback)
{
Identity ident = (SteamIdentity)callback.m_steamIDRemote;
LogUtils.LogError("P2P connection failed for: " + callback.m_steamIDRemote + ", error: " + callback.m_eP2PSessionError);
((ServerConnection)Connection).DisconnectClient(ident);
}
private static void P2PSessionConnectFail(P2PSessionConnectFail_t param)
{
Debug.LogError(string.Concat(new object[]
{
"P2PSessionConnectFail: error=",
param.m_eP2PSessionError,
", remoteId=",
param.m_steamIDRemote
}));
if (CoopLobby.Instance != null && CoopLobby.Instance.Info != null)
{
Debug.LogError("P2PSessionConnectFail: ServerId=" + CoopLobby.Instance.Info.ServerId);
P2PSessionState_t s;
if (SteamNetworking.GetP2PSessionState(CoopLobby.Instance.Info.ServerId, out s))
{
CoopSteamManager.Dump("Server", s);
}
Debug.LogError("P2PSessionConnectFail: OwnerSteamId=" + CoopLobby.Instance.Info.OwnerSteamId);
if (SteamNetworking.GetP2PSessionState(CoopLobby.Instance.Info.OwnerSteamId, out s))
{
CoopSteamManager.Dump("Lobby Owner", s);
}
}
else
{
Debug.LogError("P2PSessionConnectFail dump error: " + ((CoopLobby.Instance != null) ? "'CoopLobby.Instance.Info' is null" : "'CoopLobby.Instance' is null"));
}
}
public override bool StartClient()
{
serverUser = new User(new CSteamID(ConnectToSteamID));
#if UNITY_SERVER
if (SteamGameServerNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Connect))
#else
if (SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Connect))
#endif
{
_p2PSessionConnectFailCallback = Callback <P2PSessionConnectFail_t> .Create((sessionConnectFailInfo) =>
{
OnP2PSessionConnectFail(sessionConnectFailInfo);
});
}
else
{
P2PSessionConnectFail_t sessionConnectFailInfo = new P2PSessionConnectFail_t()
{
m_eP2PSessionError = (byte)EP2PSessionError.k_EP2PSessionErrorMax,
m_steamIDRemote = serverUser.SteamId
};
OnP2PSessionConnectFail(sessionConnectFailInfo);
return(false);
}
return(true);
}
private void OnConnectFail(P2PSessionConnectFail_t result)
{
OnConnectionFailed(result.m_steamIDRemote);
CloseP2PSessionWithUser(result.m_steamIDRemote);
switch (result.m_eP2PSessionError)
{
case 1:
Debug.LogError("Connection failed: The target user is not running the same game.");
break;
case 2:
Debug.LogError("Connection failed: The local user doesn't own the app that is running.");
break;
case 3:
Debug.LogError("Connection failed: Target user isn't connected to Steam.");
break;
case 4:
Debug.LogError("Connection failed: The connection timed out because the target user didn't respond.");
break;
default:
Debug.LogError("Connection failed: Unknown error.");
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle clients disconnecting
//-----------------------------------------------------------------------------
void OnP2PSessionConnectFail(P2PSessionConnectFail_t data)
{
if (data.m_eP2PSessionError > 0)
{
string e = string.Empty;
Logging.BMSLog.Log("OnP2PSessionConnectFail Called steamIDRemote: " + data.m_steamIDRemote);
Logging.BMSLog.Log("OnP2PSessionConnectFail error: [" + data.m_eP2PSessionError + "]"); // Riley
Disconnect(steamPlayers[data.m_steamIDRemote], true);
switch (data.m_eP2PSessionError)
{
case 1:
e = "The target user is not running the same game."; break;
case 2:
e = "The local user doesn't own the app that is running."; break;
case 3:
e = "Target user isn't connected to Steam."; break;
case 4:
e = "The connection timed out because the target user didn't respond, perhaps they aren't calling AcceptP2PSessionWithUser"; break;
}
if (e != null)
{
Logging.BMSLog.Log("<color=yellow>" + e + "</color>");
}
}
}
public override SocketTasks StartClient()
{
serverUser = new User(new CSteamID(ConnectToSteamID));
SocketTask task = SocketTask.Working;
if (SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Connect))
{
_p2PSessionConnectFailCallback = Callback <P2PSessionConnectFail_t> .Create((sessionConnectFailInfo) =>
{
OnP2PSessionConnectFail(sessionConnectFailInfo);
task.IsDone = true;
task.Success = false;
task.TransportCode = sessionConnectFailInfo.m_eP2PSessionError;
});
}
else
{
P2PSessionConnectFail_t sessionConnectFailInfo = new P2PSessionConnectFail_t()
{
m_eP2PSessionError = (byte)EP2PSessionError.k_EP2PSessionErrorMax,
m_steamIDRemote = serverUser.SteamId
};
task.IsDone = true;
task.Success = false;
task.TransportCode = sessionConnectFailInfo.m_eP2PSessionError;
OnP2PSessionConnectFail(sessionConnectFailInfo);
}
return(task.AsTasks());
}
private void OnConnectFail(P2PSessionConnectFail_t result)
{
if (LogFilter.Debug)
{
Debug.LogWarning("Connection failed or closed Steam ID " + result.m_steamIDRemote);
}
if (mode == Mode.CLIENT)
{
ClientDisconnect();
}
else if (mode == Mode.SERVER)
{
//one of the clients has disconnected
SteamClient steamClient;
try
{
steamClient = steamConnectionMap.fromSteamID[result.m_steamIDRemote];
closeSteamConnection(steamClient);
}
catch (KeyNotFoundException)
{
steamClient = null;
}
}
}
private void OnSessionConnectFail(P2PSessionConnectFail_t result)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
WeGameHelper.WriteDebugString(" OnSessionConnectFail");
Close(result.m_steamIDRemote);
}
void OnConnectFailed(P2PSessionConnectFail_t ev)
{
if (ev.m_steamIDRemote == Remote)
{
Debug.Log($"Disconnected from {Remote}");
Disconnected = true;
}
}
void OnP2PSessionConnectFail(P2PSessionConnectFail_t evt)
{
// TODO(james7132): Implement Properly
var id = evt.m_steamIDRemote;
var error = (EP2PSessionError)evt.m_eP2PSessionError;
Debug.LogError($"[Steam] Failed to connect to remote user {id}: {error}");
}
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t request)
{
if (NetworkManager.Singleton.LogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfoServer(nameof(SteamNetworkingTransport) + " - OnP2PSessionConnectFail - m_steamIDRemote: " + request.m_eP2PSessionError.ToString() + " Error: " + request.m_eP2PSessionError.ToString());
}
connectionAttemptFailed = true;
connectionAttemptFailedClientId = request.m_steamIDRemote.m_SteamID;
}
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t request)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Developer)
{
LogHelper.LogInfo("SteamP2PTransport - OnP2PSessionConnectFail - m_steamIDRemote: " + request.m_eP2PSessionError.ToString() + " Error: " + request.m_eP2PSessionError.ToString());
}
connectionAttemptFailed = true;
connectionAttemptFailedClientId = request.m_steamIDRemote.m_SteamID;
}
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t request)
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Developer)
{
UnityEngine.Debug.Log("SteamP2PTransport - OnP2PSessionConnectFail - m_steamIDRemote: " + request.m_eP2PSessionError.ToString() + " Error: " + request.m_eP2PSessionError.ToString());
}
connectionAttemptFailed = true;
connectionAttemptFailedClientId = request.m_steamIDRemote.m_SteamID;
}
private static void OnSessionConnectFailReceived(P2PSessionConnectFail_t param)
{
var error = (EP2PSessionError)param.m_eP2PSessionError;
Console.WriteLine($"OnSessionConnectFailReceived {param.m_steamIDRemote} {error}");
/*if (PortBindings.TryRemove(param.m_steamIDRemote, out ServerRetranslator retranslator))
* {
* retranslator.Dispose();
* }*/
}
private void OnSessionConnectFail(P2PSessionConnectFail_t fail)
{
if (NetworkServer.active)
{
HandleSteamServerDisconnect(fail.m_steamIDRemote, NetworkError.Timeout);
}
else
{
HandleSteamClientDisconnect(NetworkError.Timeout);
}
}
// Token: 0x060009A3 RID: 2467 RVA: 0x000466C0 File Offset: 0x000448C0
private static void OnConnectionFailed(P2PSessionConnectFail_t data)
{
ZLog.Log("Got connection failed callback: " + data.m_steamIDRemote);
foreach (ZSteamSocketOLD zsteamSocketOLD in ZSteamSocketOLD.m_sockets)
{
if (zsteamSocketOLD.IsPeer(data.m_steamIDRemote))
{
zsteamSocketOLD.Close();
}
}
}
private static void onP2PConnectionFail(P2PSessionConnectFail_t req)
{
Log.info("P2P connection status for " + req.m_steamIDRemote.m_SteamID + ": " + req.m_eP2PSessionError);
if (req.m_eP2PSessionError != 0 /*EP2PSessionError.k_EP2PSessionErrorNone*/)
{
Log.warn("Connection failed for some reason or another.");
IConnection conn;
if (conns.TryGetValue(req.m_steamIDRemote.m_SteamID, out conn))
{
conn.disconnect();
conns.Remove(req.m_steamIDRemote.m_SteamID);
}
}
}
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t callback)
{
if (P2PLogFilter.logError)
{
Debug.LogError(string.Format("[TransportLayerSteam] Connection error: {0} with steam user {1}", (EP2PSessionError)callback.m_eP2PSessionError, callback.m_steamIDRemote));
}
if (callback.m_eP2PSessionError != 0)
{
SteamNetworking.CloseP2PSessionWithUser(callback.m_steamIDRemote);
int item;
if (this.m_Connections.TryGetValue(callback.m_steamIDRemote, out item))
{
this.m_ConnectionsBrokenInternal.Push(item);
}
}
}
public override void StartClient()
{
serverUser = new User(new CSteamID(ConnectToSteamID));
if (SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Connect))
{
_p2PSessionConnectFailCallback = Callback <P2PSessionConnectFail_t> .Create(OnP2PSessionConnectFail);
}
else
{
P2PSessionConnectFail_t sessionConnectFailInfo = new P2PSessionConnectFail_t()
{
m_eP2PSessionError = (byte)EP2PSessionError.k_EP2PSessionErrorMax,
m_steamIDRemote = serverUser.SteamId
};
OnP2PSessionConnectFail(sessionConnectFailInfo);
}
}
//note: can be called on the server too probably on its first message to the client. In any case, just try to disconnect
private void OnConnectFail(P2PSessionConnectFail_t result)
{
Debug.LogWarning("Connection failed or closed Steam ID: " + result.m_steamIDRemote + " / eP2PSessionError : " + result.m_eP2PSessionError);
if (mode == Mode.CLIENT)
{
ClientDisconnect();
}
else if (mode == Mode.SERVER)
{
try
{
ServerDisconnect(steamConnectionMap.fromSteamID[result.m_steamIDRemote].connectionID);
}
catch (KeyNotFoundException)
{
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle clients disconnecting
//-----------------------------------------------------------------------------
void OnP2PSessionConnectFail(P2PSessionConnectFail_t pCallback)
{
Debug.Log("OnP2PSessionConnectFail Called steamIDRemote: " + pCallback.m_steamIDRemote); // Riley
// socket has closed, kick the user associated with it
/* TODO Riley: Disabled
* for (uint i = 0; i < MAX_PLAYERS_PER_SERVER; ++i) {
* // If there is no ship, skip
* if (!m_rgClientData[i].m_bActive)
* continue;
*
* if (m_rgClientData[i].m_SteamIDUser == pCallback.m_steamIDRemote) {
* Debug.Log("Disconnected dropped user");
* RemovePlayerFromServer(i);
* break;
* }
* }*/
}
private void OnConnectFail(P2PSessionConnectFail_t result)
{
switch (result.m_eP2PSessionError)
{
case 1:
throw new Exception("Connection failed: The target user is not running the same game.");
case 2:
throw new Exception("Connection failed: The local user doesn't own the app that is running.");
case 3:
throw new Exception("Connection failed: Target user isn't connected to Steam.");
case 4:
throw new Exception("Connection failed: The connection timed out because the target user didn't respond.");
default:
throw new Exception("Connection failed: Unknown error.");
}
}
private void OnSessionConnectFail(P2PSessionConnectFail_t result)
{
this.Close((CSteamID)result.m_steamIDRemote);
}
protected virtual void OnConnectFail(P2PSessionConnectFail_t result)
{
Debug.Log("OnConnectFail " + result);
}
public void OnP2PSessionFail(P2PSessionConnectFail_t pCallback)
{
Logger.Error($"[P2PSessionConnectFail] Could not send packet to {pCallback.m_steamIDRemote}: {pCallback}");
}
protected virtual void OnConnectFail(P2PSessionConnectFail_t result) => throw new Exception("Connection failed.");
public void P2PConnectionFail(P2PSessionConnectFail_t failResult)
{
Debug.LogError("P2P Error:" + ((EP2PSessionError)failResult.m_eP2PSessionError));
}
void OnP2PSessionConnectFail(P2PSessionConnectFail_t pCallback)
{
Debug.Log("[" + P2PSessionConnectFail_t.k_iCallback + " - P2PSessionConnectFail] - " + pCallback.m_steamIDRemote + " -- " + pCallback.m_eP2PSessionError);
}
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t callback)
{
LogUtils.LogError("P2P connection failed for: " + callback.m_steamIDRemote + ", error: " + callback.m_eP2PSessionError);
}
private void OnP2PSessionConnectFail(P2PSessionConnectFail_t pCallback)
{
Debug.Log("OnP2PSessionConnectFail Called steamIDRemote: " + pCallback.m_steamIDRemote);
}