public static void UpdatePlayerList() { // There's probably a better way to get all current active P2P connections, // but I couldn't find one. The SessionInfo pointers are not reliable as // players can spoof their Steam ID there. int cnt = SteamFriends.GetCoplayFriendCount(); for (int i = 0; i < cnt; i++) { CSteamID id = SteamFriends.GetCoplayFriend(i); P2PSessionState_t session = new P2PSessionState_t(); if (!SteamNetworking.GetP2PSessionState(id, out session) || (session.m_bConnectionActive == 0 && session.m_bConnecting == 0)) { if (activePlayers.ContainsKey(id)) { ETWPingMonitor.Unregister(activePlayers[id].NetId); activePlayers.Remove(id); } continue; } if (!activePlayers.ContainsKey(id)) { activePlayers[id] = new Player(id); } activePlayers[id].UpdateNetInfo(session); } }
private void UpdateNetInfo(P2PSessionState_t session) { bool endpointChanged = sessionState.m_nRemoteIP != session.m_nRemoteIP || sessionState.m_nRemotePort != session.m_nRemotePort; sessionState = session; if (endpointChanged) { // If IP/port changed for whatever reason ETWPingMonitor.Unregister(NetId); Region = "..."; byte[] ipBytes = BitConverter.GetBytes(sessionState.m_nRemoteIP).Reverse().ToArray(); NetId = (ulong)sessionState.m_nRemotePort << 32 | BitConverter.ToUInt32(ipBytes, 0); ETWPingMonitor.Register(NetId); if (session.m_bUsingRelay == 0) { IpLocationAPI.GetLocationAsync(new IPAddress(ipBytes).ToString(), r => Region = r); } else { Region = "[STEAM RELAY]"; } } }
public static void UpdatePlayerList() { // There's probably a better way to get all current active P2P connections, // but I couldn't find one. The SessionInfo pointers are not reliable as // players can spoof their Steam ID there. int cnt = SteamApi.SteamFriends.GetCoplayFriendCount(); for (int i = 0; i < cnt; i++) { ulong id = SteamApi.SteamFriends.GetCoplayFriend(i); P2PSessionState_t session = new P2PSessionState_t(); if (!SteamApi.SteamNetworking.GetP2PSessionState(id, ref session) || session.m_bConnectionActive == 0) { activePlayers.Remove(id); } else if (!activePlayers.ContainsKey(id)) { activePlayers[id] = new Player(id, session); } else { activePlayers[id].UpdateNetInfo(session); } } }
private void OnLobbyEntered(LobbyEnter_t result, bool failure) { //IL_001e: Unknown result type (might be due to invalid IL or missing references) //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0082: Unknown result type (might be due to invalid IL or missing references) //IL_0094: Unknown result type (might be due to invalid IL or missing references) //IL_00a4: Unknown result type (might be due to invalid IL or missing references) //IL_00b2: Unknown result type (might be due to invalid IL or missing references) //IL_00ca: Unknown result type (might be due to invalid IL or missing references) //IL_00db: Unknown result type (might be due to invalid IL or missing references) //IL_0127: Unknown result type (might be due to invalid IL or missing references) WeGameHelper.WriteDebugString(" OnLobbyEntered"); SteamNetworking.AllowP2PPacketRelay(true); SendAuthTicket(_lobby.Owner); int num = 0; P2PSessionState_t val = default(P2PSessionState_t); while (SteamNetworking.GetP2PSessionState(_lobby.Owner, ref val) && val.m_bConnectionActive != 1) { switch (val.m_eP2PSessionError) { case 2: ClearAuthTicket(); return; case 1: ClearAuthTicket(); return; case 3: ClearAuthTicket(); return; case 5: ClearAuthTicket(); return; case 4: if (++num > 5) { ClearAuthTicket(); return; } SteamNetworking.CloseP2PSessionWithUser(_lobby.Owner); SendAuthTicket(_lobby.Owner); break; } } _connectionStateMap[_lobby.Owner] = ConnectionState.Connected; SteamFriends.SetPlayedWith(_lobby.Owner); SteamFriends.SetRichPresence("status", Language.GetTextValue("Social.StatusInGame")); Main.clrInput(); Netplay.ServerPassword = ""; Main.GetInputText(""); Main.autoPass = false; Main.netMode = 1; Netplay.OnConnectedToSocialServer(new SocialSocket(new SteamAddress(_lobby.Owner))); }
protected P2PSessionState_t GetSessionState(CSteamID userId) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0009: Unknown result type (might be due to invalid IL or missing references) P2PSessionState_t result = default(P2PSessionState_t); SteamNetworking.GetP2PSessionState(userId, out result); return(result); }
public static void PostFixObj(CSteamID steamIDRemote, ref P2PSessionState_t pConnectionState) { SteamPlayer pl = PlayerTool.getSteamPlayer(steamIDRemote); if (pl.transportConnection.TryGetIPv4Address(out uint IP)) { pConnectionState.m_nRemoteIP = IP; } }
private Player(ulong steamID, P2PSessionState_t session) { SteamID = steamID; SteamName = FixedPersonaName(steamID); CharSlot = ""; TeamId = -1; CharName = ""; UpdateNetInfo(session); }
private Player(CSteamID steamID) { SteamID = steamID; SteamName = SteamFriends.GetFriendPersonaName(steamID); NetId = 0; sessionState = new P2PSessionState_t(); CharSlot = ""; TeamId = -1; CharName = ""; }
public static void Dump(string tag, P2PSessionState_t s) { Debug.Log("##### " + tag + " #####"); Debug.Log("m_bConnecting: " + s.m_bConnecting); Debug.Log("m_bConnectionActive: " + s.m_bConnectionActive); Debug.Log("m_bUsingRelay: " + s.m_bUsingRelay); Debug.Log("m_eP2PSessionError: " + s.m_eP2PSessionError); Debug.Log("m_nBytesQueuedForSend: " + s.m_nBytesQueuedForSend); Debug.Log("m_nPacketsQueuedForSend: " + s.m_nPacketsQueuedForSend); Debug.Log("m_nRemoteIP: " + s.m_nRemoteIP); Debug.Log("m_nRemotePort: " + s.m_nRemotePort); }
private void UpdateNetInfo(P2PSessionState_t session) { if (sessionState.m_nRemoteIP == session.m_nRemoteIP) { return; } sessionState = session; Ip = null; Region = "..."; if (session.m_bUsingRelay == 0) { byte[] ipBytes = BitConverter.GetBytes(sessionState.m_nRemoteIP).Reverse().ToArray(); Ip = new IPAddress(ipBytes); IpLocationAPI.GetLocationAsync(Ip.ToString(), r => Region = r); } }
private void OnP2PSessionRequest(P2PSessionRequest_t result) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_000d: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Unknown result type (might be due to invalid IL or missing references) //IL_0023: Unknown result type (might be due to invalid IL or missing references) //IL_004c: Unknown result type (might be due to invalid IL or missing references) //IL_004d: Unknown result type (might be due to invalid IL or missing references) //IL_0053: Invalid comparison between Unknown and I4 //IL_0056: Unknown result type (might be due to invalid IL or missing references) //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0067: Unknown result type (might be due to invalid IL or missing references) //IL_0070: Unknown result type (might be due to invalid IL or missing references) //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_0085: Unknown result type (might be due to invalid IL or missing references) //IL_0092: Unknown result type (might be due to invalid IL or missing references) CSteamID steamIDRemote = result.m_steamIDRemote; if (_connectionStateMap.ContainsKey(steamIDRemote) && _connectionStateMap[steamIDRemote] != 0) { SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote); } else if (_acceptingClients && (_mode.HasFlag(ServerMode.FriendsOfFriends) || (int)SteamFriends.GetFriendRelationship(steamIDRemote) == 3)) { SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote); P2PSessionState_t val = default(P2PSessionState_t); while (SteamNetworking.GetP2PSessionState(steamIDRemote, ref val) && val.m_bConnecting == 1) { } if (val.m_bConnectionActive == 0) { Close(steamIDRemote); } _connectionStateMap[steamIDRemote] = ConnectionState.Authenticating; _connectionAcceptedCallback(new SocialSocket(new SteamAddress(steamIDRemote))); } }
public static bool GetP2PSessionState(CSteamID steamIDRemote, out P2PSessionState_t pConnectionState) { InteropHelp.TestIfAvailableGameServer(); return(NativeMethods.ISteamGameServerNetworking_GetP2PSessionState(steamIDRemote, out pConnectionState)); }
// bool public bool GetP2PSessionState(CSteamID steamIDRemote /*class CSteamID*/, ref P2PSessionState_t pConnectionState /*struct P2PSessionState_t **/) { return(platform.ISteamNetworking_GetP2PSessionState(steamIDRemote.Value, ref pConnectionState)); }
private IEnumerator DumpPlayer(Player player) { var now = DateTime.Now; string timeFormat = $"{now.Year}_{now.Month}_{now.Day}_{now.Hour}_{now.Minute}_{now.Second}"; void AppendToOutput(string prefix, string value, int indent = 2) { string output = ""; for (int i = 0; i < indent; i++) { output += "\t"; } if (prefix == "") { output += value; } else { output += $"{prefix}: {value}"; } output += "\n"; m_fileSystem.SaveText($"{timeFormat} {player.ApiUser().displayName}.txt", output, true); } AppendToOutput("", "[[", 0); AppendToOutput("", "USER", 1); AppendToOutput("Display Name", player.ApiUser().displayName); AppendToOutput("Login Name", player.ApiUser().username); AppendToOutput("Id", player.ApiUser().id); AppendToOutput("SteamId", player.vrcPlayer.SteamUserIdULong().ToString()); AppendToOutput("Status", player.ApiUser().statusDescription); if (player.vrcPlayer.SteamUserIdULong() != 0UL) { CSteamID id = new CSteamID(player.vrcPlayer.SteamUserIdULong()); MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); int version = VRCApplicationSetupWrappers.Instance.GetGameServerVersion().GetHashCode(); writer.Write(version); writer.Write(0); byte[] data = ms.ToArray(); writer.Close(); ms.Close(); SteamNetworking.SendP2PPacket(id, data, (uint)data.Length, EP2PSend.k_EP2PSendUnreliable); P2PSessionState_t state = default(P2PSessionState_t); if (SteamNetworking.GetP2PSessionState(id, out state)) { Log.Debug("Waiting for connection to be established..."); while (state.m_bConnecting == 1) { Log.Debug($"state: m_bConnecting: {state.m_bConnecting}, m_bConnectionActive: {state.m_bConnectionActive}, m_eP2PSessionError: {state.m_eP2PSessionError}"); Log.Debug($"m_bUsingRelay: {state.m_bUsingRelay}, m_nBytesQueuedForSend: {state.m_nBytesQueuedForSend}, m_nPacketsQueuedForSend: {state.m_nPacketsQueuedForSend}"); Log.Debug($"m_nRemoteIP: {state.m_nRemoteIP}, m_nRemotePort: {state.m_nRemotePort}"); yield return(new WaitForSeconds(1f)); } Log.Debug("Connection established, retreiving ip!"); string IpToStr(uint ip) { return(new IPAddress(new byte[] { (byte)(ip >> 24 & 255u), (byte)(ip >> 16 & 255u), (byte)(ip >> 8 & 255u), (byte)(ip & 255u) }).ToString()); } string relay = (state.m_bUsingRelay == 1) ? "(STEAM RELAY)" : ""; AppendToOutput($"IP {relay}", IpToStr(state.m_nRemoteIP)); } } ApiAvatar avatar = player.vrcPlayer.ApiAvatar(); AppendToOutput("", "AVATAR", 1); AppendToOutput("Name", avatar.name); AppendToOutput("Author", avatar.authorName); AppendToOutput("Status", avatar.releaseStatus); AppendToOutput("VRCA", avatar.assetUrl); AppendToOutput("", "]]", 0); }
/// <summary> /// <para> fills out P2PSessionState_t structure with details about the underlying connection to the user</para> /// <para> should only needed for debugging purposes</para> /// <para> returns false if no connection exists to the specified user</para> /// </summary> public static bool GetP2PSessionState(CSteamID steamIDRemote, out P2PSessionState_t pConnectionState) { InteropHelp.TestIfAvailableClient(); return(NativeMethods.ISteamNetworking_GetP2PSessionState(CSteamAPIContext.GetSteamNetworking(), steamIDRemote, out pConnectionState)); }
private static void P2PSessionState(P2PSessionState_t param) { Debug.Log("param.m_bConnectionActive: " + param.m_bConnectionActive); }
internal bool GetP2PSessionState(SteamId steamIDRemote, ref P2PSessionState_t pConnectionState) { var returnValue = _GetP2PSessionState(Self, steamIDRemote, ref pConnectionState); return(returnValue); }
public abstract bool GetP2PSessionState(ulong steamIDRemote,ref P2PSessionState_t pConnectionState);
public override bool GetP2PSessionState(ulong steamIDRemote,ref P2PSessionState_t pConnectionState) { CheckIfUsable(); bool result = NativeEntrypoints.SteamAPI_ISteamNetworking_GetP2PSessionState(m_pSteamNetworking,steamIDRemote,ref pConnectionState); return result; }
public static IPAddress GetRemoteIP(this P2PSessionState_t state) { // What is endianness anyway? return(new IPAddress(BitConverter.GetBytes(state.m_nRemoteIP).Reverse().ToArray())); }
private static extern bool _GetP2PSessionState(IntPtr self, SteamId steamIDRemote, ref P2PSessionState_t pConnectionState);