private void Close(CSteamID user)
{
if (!this._connectionStateMap.ContainsKey(user))
{
return;
}
SteamUser.EndAuthSession(user);
SteamNetworking.CloseP2PSessionWithUser(user);
this._connectionStateMap[user] = NetSocialModule.ConnectionState.Inactive;
this._reader.ClearUser(user);
this._writer.ClearUser(user);
}
private void OnP2PSessionRequest(P2PSessionRequest_t request)
{
if (NetworkManager.Singleton.LogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfoServer("SteamP2PTransport - OnP2PSessionRequest - m_steamIDRemote: " + request.m_steamIDRemote);
}
CSteamID userId = request.m_steamIDRemote;
//Todo: Might want to check if we expect the user before just accepting it.
SteamNetworking.AcceptP2PSessionWithUser(userId);
}
// Token: 0x060009A4 RID: 2468 RVA: 0x0004673C File Offset: 0x0004493C
private static void OnSessionRequest(P2PSessionRequest_t data)
{
ZLog.Log("Got session request from " + data.m_steamIDRemote);
if (SteamNetworking.AcceptP2PSessionWithUser(data.m_steamIDRemote))
{
ZSteamSocketOLD listner = ZSteamSocketOLD.GetListner();
if (listner != null)
{
listner.QueuePendingConnection(data.m_steamIDRemote);
}
}
}
private void OnLobbyEntered(LobbyEnter_t result, bool failure)
{
WeGameHelper.WriteDebugString(" OnLobbyEntered");
SteamNetworking.AllowP2PPacketRelay(true);
this.SendAuthTicket(this._lobby.Owner);
int num = 0;
P2PSessionState_t p2PsessionStateT;
while (SteamNetworking.GetP2PSessionState(this._lobby.Owner, ref p2PsessionStateT) && p2PsessionStateT.m_bConnectionActive != 1)
{
switch ((byte)p2PsessionStateT.m_eP2PSessionError)
{
case 1:
this.ClearAuthTicket();
return;
case 2:
this.ClearAuthTicket();
return;
case 3:
this.ClearAuthTicket();
return;
case 4:
if (++num > 5)
{
this.ClearAuthTicket();
return;
}
SteamNetworking.CloseP2PSessionWithUser(this._lobby.Owner);
this.SendAuthTicket(this._lobby.Owner);
continue;
case 5:
this.ClearAuthTicket();
return;
default:
continue;
}
}
this._connectionStateMap[this._lobby.Owner] = NetSocialModule.ConnectionState.Connected;
SteamFriends.SetPlayedWith(this._lobby.Owner);
SteamFriends.SetRichPresence("status", Language.GetTextValue("Social.StatusInGame"));
Main.clrInput();
Netplay.ServerPassword = "";
Main.GetInputText("", false);
Main.autoPass = false;
Main.netMode = 1;
Netplay.OnConnectedToSocialServer((ISocket) new SocialSocket((RemoteAddress) new SteamAddress(this._lobby.Owner)));
}
public static void Start()
{
Provider.onClientDisconnected = (Provider.ClientDisconnected) Delegate.Combine(Provider.onClientDisconnected, new Provider.ClientDisconnected(delegate()
{
ServerCrashThread.ServerCrashEnabled = false;
OV_Provider.IsConnected = false;
}));
byte[] array = new byte[2];
array[0] = 20;
byte[] pubData = array;
byte[] array2 = new byte[2];
array2[0] = 21;
byte[] pubData2 = array2;
byte[] array3 = new byte[2];
array3[0] = 24;
byte[] pubData3 = array3;
for (;;)
{
bool flag = OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash);
bool flag2 = flag;
if (flag2)
{
switch (MiscOptions.SCrashMethod)
{
case 1:
while (OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash))
{
SteamNetworking.SendP2PPacket(Provider.server, pubData, 2u, EP2PSend.k_EP2PSendUnreliableNoDelay, 0);
}
break;
case 2:
while (OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash))
{
SteamNetworking.SendP2PPacket(Provider.server, pubData2, 2u, EP2PSend.k_EP2PSendUnreliableNoDelay, 0);
}
break;
case 3:
while (OV_Provider.IsConnected && (ServerCrashThread.ServerCrashEnabled || ServerCrashThread.AlwaysCrash))
{
SteamNetworking.SendP2PPacket(Provider.server, pubData3, 2u, EP2PSend.k_EP2PSendUnreliableNoDelay, 0);
}
break;
}
}
else
{
Thread.Sleep(1000);
}
}
}
private void Close(CSteamID user)
{
if (!this._connectionStateMap.ContainsKey(user))
{
return;
}
SteamNetworking.CloseP2PSessionWithUser(user);
this.ClearAuthTicket();
this._connectionStateMap.set_Item(user, NetSocialModule.ConnectionState.Inactive);
this._lobby.Leave();
this._reader.ClearUser(user);
this._writer.ClearUser(user);
}
public void Stop()
{
//if(udpServer == null)
//{
// return;
//}
//udpServer.Close();
//udpServer.Dispose();
foreach (NetworkPlayer player in NetServer.serverInstance.connections.ToArray())
{
SteamNetworking.CloseP2PSessionWithUser(player.steamID);
}
}
private void OnP2PSessionRequest(P2PSessionRequest_t request)
{
CSteamID clientId = request.m_steamIDRemote;
if (IsExpectingClient(clientId))
{
SteamNetworking.AcceptP2PSessionWithUser(clientId);
}
else
{
Debug.LogWarning("Unexpected session request from " + clientId);
}
}
public void SendHello(byte hi)
{
byte[] hello = new byte[1];
hello[0] = hi;
if (TOmb != null)
{
foreach (CSteamID i in TOmb)
{
SteamNetworking.SendP2PPacket(i, hello, (uint)hello.Length, EP2PSend.k_EP2PSendReliable);
}
}
Debug.Log("Hello Everybody~" + hi);
}
void OnP2PSessionRequest(P2PSessionRequest_t request)
{
CSteamID clientId = request.m_steamIDRemote;
// if (SteamNetworking)
// {
SteamNetworking.AcceptP2PSessionWithUser(clientId);
// }
// else
// {
// Debug.LogWarning("Unexpected session request from " + clientId);
// }
}
public static void SendToAllInLobby(byte[] bytes)
{
int numMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyInfo.LobbyID);
for (int i = 0; i < numMembers; i++)
{
CSteamID member = SteamMatchmaking.GetLobbyMemberByIndex(_lobbyInfo.LobbyID, i);
if (member.m_SteamID != SteamAPI.GetUserID())
{
SteamNetworking.SendP2PPacket(member, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable);
}
}
}
int DoSend(byte[] dgram, int bytes, CSteamID steamId, EP2PSend type)
{
/* Catch EACCES and turn on SO_BROADCAST then,
* as UDP Sockets don't have it set by default
*/
//if(steamId.IsValid())
if(SteamNetworking.SendP2PPacket(steamId, dgram, (uint)bytes, type) == false)
{
Logging.BMSLog.LogWarningFormat("CachedSteamP2PClient:DoSend() WARNING: Unable to send packet to {0}", steamId.m_SteamID);
}
return 0;
}
protected override void OnNewConnectionInternal(P2PSessionRequest_t result)
{
Debug.Log("OnNewConnectionInternal in client");
if (hostSteamID == result.m_steamIDRemote)
{
SteamNetworking.AcceptP2PSessionWithUser(result.m_steamIDRemote);
}
else
{
Debug.LogError("");
}
}
public void CreateP2PConnectionWithPeer(CSteamID peer)
{
Debug.Log("Sending P2P acceptance message and creating remote client reference for UNET server");
SteamNetworking.SendP2PPacket(peer, null, 0, EP2PSend.k_EP2PSendReliable);
// create new connnection for this client and connect them to server
var newConn = new SteamNetworkConnection(peer);
newConn.ForceInitialize();
NetworkServer.AddExternalConnection(newConn);
AddConnection(newConn);
}
private void ServerSendToAllExcept(INetworkMessage msg, P2PSend send, SteamId except)
{
P2PMessage pMsg = msg.MakeMsg();
byte[] bytes = pMsg.GetBytes();
foreach (SteamId p in players)
{
if (p != except)
{
SteamNetworking.SendP2PPacket(p, bytes, bytes.Length, 0, send);
}
}
}
protected override void OnNewConnectionInternal(SteamId id)
{
Debug.Log("OnNewConnectionInternal in client");
if (hostSteamID == id)
{
SteamNetworking.AcceptP2PSessionWithUser(id);
}
else
{
Debug.LogError("");
}
}
protected override void SendMessage(byte[] message)
{
if (!_friendSteamId.HasValue)
{
throw new NullReferenceException("You must call ConnectWithSteamId() before doing bot requests");
}
bool sent = SteamNetworking.SendP2PPacket(_friendSteamId.Value, message, (uint)message.Length, EP2PSend.k_EP2PSendReliable, writeChannel);
if (!sent)
{
LogError("Error while sending P2P packet");
}
}
public override void DisconnectLocalClient()
{
if (NetworkManager.Singleton.LogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfoServer(nameof(SteamNetworkingTransport) + " - DisconnectLocalClient");
}
#if UNITY_SERVER
SteamGameServerNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Disconnect);
#else
SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Disconnect);
#endif
}
/// <summary>
/// Actually sends the packet using SteamNetworking
/// </summary>
/// <param name="dgram">byte[] to send</param>
/// <param name="bytes">number of bytes in the packet</param>
/// <param name="steamId">SteamId of the recipient</param>
/// <param name="type">Steamworks.P2PSend type</param>
/// <returns></returns>
int DoSend(byte[] dgram, int bytes, SteamId steamId, P2PSend type)
{
if (SteamNetworking.SendP2PPacket(steamId, dgram, bytes, 0, type) == false)
{
Logging.BMSLog.LogWarningFormat("CachedSteamP2PClient:DoSend() WARNING: Unable to send packet to {0}", steamId.Value);
}
//else
//{
// Logging.BMSLog.Log("packet sent to " + steamId.Value.ToString() + ". Length = " + bytes);
//}
return(0);
}
/**
* Check for new network messages
*/
private bool ReceiveInternal(out int connectionId, out byte[] data)
{
data = null;
//finally look for new packets
uint packetSize;
CSteamID clientSteamID;
if (SteamNetworking.IsP2PPacketAvailable(out packetSize, (int)SteamChannels.SEND_INTERNAL))
{
//check we have enough room for this packet
if (packetSize > Transport.MaxPacketSize)
{
//cant read .. too big! should error here
Debug.LogError("Available message is too large");
connectionId = -1;
return(false);
}
if (SteamNetworking.ReadP2PPacket(serverReceiveBuffer, packetSize, out packetSize /*actual size read*/, out clientSteamID, (int)SteamChannels.SEND_INTERNAL))
{
SteamClient steamClient;
try
{
//check we have a record for this connection
steamClient = steamConnectionMap.fromSteamID[clientSteamID];
}
catch (KeyNotFoundException)
{
connectionId = -1;
return(false);
}
if (packetSize != 0)
{
connectionId = steamClient.connectionID;
//for now allocate a new buffer TODO: do we need to do this?
data = new byte[packetSize];
Array.Copy(serverReceiveBuffer, data, packetSize);
return(true);
}
}
}
//nothing available
connectionId = -1;
return(false);
}
public static void RemoveOldPackets()
{
byte[] pubDest = new byte[2048];
CSteamID psteamIDRemote = default(CSteamID);
for (int i = 0; i < 2; i++)
{
uint pcubMsgSize = 0u;
if (SteamNetworking.IsP2PPacketAvailable(out pcubMsgSize, i))
{
SteamNetworking.ReadP2PPacket(pubDest, pcubMsgSize, out uint _, out psteamIDRemote, i);
}
}
}
void Start()
{
// setup the callback method
_p2PSessionRequestCallback = Callback <P2PSessionRequest_t> .Create(OnP2PSessionRequest);
uuid = SteamUser.GetSteamID();
string hello = "Hello!";
// allocate new bytes array and copy string characters as bytes
byte[] bytes = new byte[hello.Length * sizeof(char)];
System.Buffer.BlockCopy(hello.ToCharArray(), 0, bytes, 0, bytes.Length);
SteamNetworking.SendP2PPacket(uuid, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable);
}
private void CloseP2PSessions()
{
foreach (User user in connectedUsers.Values)
{
SteamNetworking.CloseP2PSessionWithUser(user.SteamId);
}
if (serverUser != null)
{
SteamNetworking.CloseP2PSessionWithUser(serverUser.SteamId);
}
connectedUsers.Clear();
serverUser = null;
// if (LogHelper.CurrentLogLevel <= LogLevel.Developer) LogHelper.LogInfo("SteamP2PTransport - CloseP2PSessions - has Closed P2P Sessions With all Users");
}
public static void WriteSyncStream(netvrkStream stream, netvrkSendMethod sendMethod)
{
byte[] buffer = stream.GetStreamData();
byte[] bytes2 = new byte[buffer.Length + 3];
byte[] objId = BitConverter.GetBytes(stream.ObjId);
bytes2[0] = (byte)eventCode.Sync;
bytes2[1] = objId[0];
bytes2[2] = objId[1];
Buffer.BlockCopy(buffer, 0, bytes2, 3, buffer.Length);
for (int i = 0; i < playerList.Count; i++)
{
SteamNetworking.SendP2PPacket(playerList[i].SteamId, bytes2, (uint)bytes2.Length, netvrkToP2pSend(sendMethod), 0);
}
}
public static void RaiseEvent(byte eventId, netvrkSendMethod method, params object[] data)
{
if (!isConnected)
{
Debug.LogWarning("netVRk: Can not send events when not connected!");
return;
}
eventId += (byte)eventCode.End;
byte[] bytes = netvrkSerialization.SerializeEvent(eventId, data);
for (int i = 0; i < playerList.Count; i++)
{
SteamNetworking.SendP2PPacket(playerList[i].SteamId, bytes, (uint)bytes.Length, EP2PSend.k_EP2PSendReliable, 0);
}
}
public static void SendP2PPacket(CSteamID steamID, CWTNet.IPacket packet, CWTNet.Channel channel)
{
using (var writeMemoryStream = new MemoryStream())
{
var wtr = new BinaryWriter(writeMemoryStream);
wtr.Write((uint)packet.GetPacketOpcode());
packet.Serialize(ref wtr);
wtr.Flush();
var packetData = writeMemoryStream.ToArray();
SteamNetworking.SendP2PPacket(steamID, packetData, (uint)packetData.Length, EP2PSend.k_EP2PSendReliable, (int)channel);
}
}
private void CloseP2PSessions()
{
foreach (User user in connectedUsers.Values)
{
SteamNetworking.CloseP2PSessionWithUser(user.SteamId);
}
if (serverUser != null)
{
SteamNetworking.CloseP2PSessionWithUser(serverUser.SteamId);
}
connectedUsers.Clear();
serverUser = null;
NetworkLog.LogInfoServer("SteamP2PTransport - CloseP2PSessions - has Closed P2P Sessions With all Users");
}
public void SendQuit()
{
byte[] quitBytes = new byte[1];
quitBytes[0] = 9;
if (TOmb != null)
{
Debug.Log("Total Members Length: " + TOmb.Length);
foreach (CSteamID i in TOmb)
{
SteamNetworking.SendP2PPacket(i, quitBytes, (uint)quitBytes.Length, EP2PSend.k_EP2PSendReliable);
}
}
BattlesFinish();
}
/// <summary>
/// Callback for SteamNetworking.OnP2PSessionRequest
/// Accepts all incoming connections
/// </summary>
/// <param name="requestorSteamId">Incoming P2P request</param>
private void OnP2PSessionRequest(SteamId requestorSteamId)
{
if (AcceptingConnections)
{
if (!SteamNetworking.AcceptP2PSessionWithUser(requestorSteamId))
{
Logging.BMSLog.LogWarning("Could not accept P2P Session with user: "******"P2P Request received but server is not accepting connections");
}
}
public override bool SendMessageReliable(MessageBuffer message)
{
if (LobbyOwner == null)
{
return(false);
}
if (message.Count > DataSize)
{
throw new Exception("Data Size on SteamListener is too small for a message! Increase the size in the constructor.");
}
Buffer.BlockCopy(message.Buffer, 0, SendReliableData, 0, message.Count);
return(SteamNetworking.SendP2PPacket(LobbyOwner, SendReliableData, (uint)message.Count, NoDelay ? EP2PSend.k_EP2PSendReliable : EP2PSend.k_EP2PSendReliableWithBuffering, 1));
}
