public void SendMessage(IPeerMessage message)
{
using (var ms = new MemoryStream())
{
BinaryWriter w = new BigEndianBinaryWriter(ms);
message.Send(w);
Send(ms.ToArray());
}
}
public override void onReceiveMessage(IPeerMessage message)
{
Received += (ulong)message.DecompressedRawSize;
PacketsPerSec++;
(message as TestMessage).Stuff = new byte[5];
SendMessage(message);
if (sw.ElapsedMilliseconds >= 1000)
{
Console.WriteLine("[Rootsocket] last size: " + message.DecompressedRawSize + ", pps:" + PacketsPerSec + ", data/sec:" + Received + " [" + Math.Round(((float)Received / 1000F) / 1000F, 2) + "MBps] " + (Math.Round((((float)Received / 1000F) / 1000F) / 1000F, 2) * 8F) + "Gbps");
sw = Stopwatch.StartNew();
Received = 0;
PacketsPerSec = 0;
}
}
public void SendMessage(IPeerMessage message)
{
if (!Connected)
{
return;
}
message.ConnectionId = this.ConnectionId;
Connection conn = _client.Connection;
NetworkPayloadWriter temp = message.WritePacket(message, conn);
message.RawSize = temp.Length - _client.Connection.HEADER_SIZE;
//apply compression, encryption, masks here
conn.SendPayload(temp, conn.messageHandler.GetMessageId(message.GetType()), PacketId.RootSocket_Payload, false, null, null, VirtualIpInt);
}
public override void onReceiveMessage(IPeerMessage message)
{
}
private void onRootSocketQueue(IPeerMessage message)
{
message.Peer.onReceiveMessage(message);
}
private unsafe void networkStreamCallback(Network.NetworkStream stream)
{
lock (stream)
{
bool DataAvailable = true;
while (DataAvailable)
{
switch (this.stream.ReceiveState)
{
case ReceiveType.Header:
{
if (stream.CanRead(HEADER_SIZE))
{
byte[] headerData = new byte[HEADER_SIZE];
if (stream.Read(ref headerData, 0, headerData.Length) > 0)
{
//wopEncryption.Decrypt(header, 0, HEADER_SIZE);
stream.NetworkPayload.Header = new PacketHeader(headerData, 0, this);
if (!DPI.Inspect(stream.NetworkPayload.Header))
{
Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
return;
}
this.stream.ReceiveState = ReceiveType.Payload;
}
}
else
{
DataAvailable = false;
}
break;
}
case ReceiveType.Payload:
{
if (stream.CanRead(stream.NetworkPayload.Header.PacketSize))
{
int receivedSize = stream.NetworkPayload.Header.PacketSize;
uint packetSize = (uint)stream.NetworkPayload.Header.PacketSize;
byte[] payload = stream.Buffer;
uint offset = (uint)stream.Position;
PacketHeader header = stream.NetworkPayload.Header;
IPlugin plugin = null;
uint GenHash = 0;
if (stream.NetworkPayload.Header.PacketID == PacketId.PluginPacket)
{
plugin = pluginSystem.GetPlugin(stream.NetworkPayload.Header.PluginId);
if (plugin == null)
{
throw new Exception("Plugin not found");
}
}
if (Client.Certificate != null)
{
GenHash = stream.NetworkPayload.Header.HashPayload(payload, (int)offset, (int)packetSize, Client.Certificate.Checksum);
if (stream.NetworkPayload.Header.Hash != GenHash)
{
Client.Disconnect(DisconnectReason.DataModificationDetected);
return;
}
}
//peer code
if (stream.NetworkPayload.Header.PeerId != 0 && stream.NetworkPayload.Header.PacketID == PacketId.RootSocket_Payload)
{
if (stream.NetworkPayload.Header.PeerId == Client.VirtualIpInt && !Client.ServerSided)
{
//we arrived at the target peer !
IPeerMessage PeerMsg = null;
try
{
PeerMsg = (IPeerMessage)messageHandler.HandleMessage(new PayloadReader(payload)
{
Offset = (int)offset
}, stream.NetworkPayload.Header.MessageId);
if (PeerMsg != null)
{
PeerMsg.RawSize = stream.NetworkPayload.Header.PacketSize;
PeerMsg.DecompressedRawSize = payload.Length;
}
}
catch (Exception ex)
{
Client.onException(ex, ErrorType.Core);
return;
}
lock (Client.PeerConnections)
{
RootPeer peer = null;
if (Client.PeerConnections.TryGetValue(PeerMsg.ConnectionId, out peer))
{
/*try
* {
* if (!peer.DPI.Inspect(stream.NetworkPayload.Header, PeerMsg))
* {
* Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
* return;
* }
* }
* catch { }*/
PeerMsg.Peer = peer;
RootSocketQueue.Enqueue(PeerMsg);
}
}
}
else if (Client.ServerSided)
{
SSPClient TargetClient = null;
lock (Client.PeerConnections)
{
for (int i = 0; i < Client.PeerConnections.Count; i++)
{
RootPeer rootPeer = Client.PeerConnections.Values[i];
if (rootPeer.FromClient != null && rootPeer.FromClient.VirtualIpInt == stream.NetworkPayload.Header.PeerId)
{
TargetClient = rootPeer.FromClient;
break;
}
if (rootPeer.ToClient != null && rootPeer.ToClient.VirtualIpInt == stream.NetworkPayload.Header.PeerId)
{
TargetClient = rootPeer.ToClient;
break;
}
}
}
if (TargetClient != null)
{
//no protection is being applied to the payload
//the protection should already have been applied
//when the client sended this data to the server
NetworkPayloadWriter pw = new NetworkPayloadWriter(this);
pw.WriteBytes(payload, (int)offset, receivedSize);
TargetClient.Connection.SendPayload(pw, stream.NetworkPayload.Header.MessageId,
PacketId.RootSocket_Payload, false, null, null,
stream.NetworkPayload.Header.PeerId);
}
}
else
{
//strange...
}
this.stream.ReceiveState = ReceiveType.Header;
stream.Position += receivedSize;
payload = null;
break;
}
//decrypt, decompress, de-cache the data we received
if (plugin != null && plugin.UseOwnProtection)
{
payload = plugin.protection.RemoveProtection(payload, ref offset, ref packetSize, ref stream.NetworkPayload.Header);
}
else
{
payload = protection.RemoveProtection(payload, ref offset, ref packetSize, ref stream.NetworkPayload.Header);
}
/*
* if (stream.NetworkPayload.isCached)
* {
* payload = ReceiveCache.DeCache(payload, offset, packetSize);
* offset = 0;
* packetSize = payload.Length;
* }*/
IMessage message = null;
try
{
message = messageHandler.HandleMessage(new PayloadReader(payload)
{
Offset = (int)offset
}, stream.NetworkPayload.Header.MessageId);
if (message != null)
{
message.RawSize = stream.NetworkPayload.Header.PacketSize;
message.DecompressedRawSize = payload.Length;
}
}
catch (Exception ex)
{
Client.onException(ex, ErrorType.Core);
return;
}
if (!Client.DPI.Inspect(null, message))
{
Client.Disconnect(DisconnectReason.DeepPacketInspectionDisconnection);
return;
}
/*if(ProcessSpeed == ReceivePerformance.Unsafe)
* {
* if(!MovedPayload && plugin != null && (plugin.UseOwnSystem))
* {
* //payload is not moved from memory and plugin is using his own system
* //We'll just copy the memory...
* payload = new byte[packetSize];
* fixed (byte* dataPtr = payload, streamPtr = stream.Buffer)
* {
* NativeMethods.memcpy(dataPtr, streamPtr, (uint)packetSize);
* }
* }
* }*/
switch (stream.NetworkPayload.Header.PacketID)
{
case PacketId.PacketQueue:
{
PacketTaskQueue.Enqueue(message);
break;
}
case PacketId.ChannelPayload:
{
ChannelPayloadQueue.Enqueue(new ChannelRecvInfo(message, stream.NetworkPayload.Header.ChannelId));
break;
}
case PacketId.CloseChannel:
{
CloseChannelQueue.Enqueue(message);
break;
}
case PacketId.Disconnected:
{
DisconnectedQueue.Enqueue(message);
break;
}
case PacketId.OpenChannel:
{
OpenChannelQueue.Enqueue(message);
break;
}
case PacketId.OpenChannelResponse:
case PacketId.LiteCodeResponse:
case PacketId.KeepAlive:
{
ResponseQueue.Enqueue(message);
break;
}
case PacketId.Payload:
{
PayloadQueue.Enqueue(message);
break;
}
case PacketId.PluginPacket:
{
PluginDataQueue.Enqueue(new PluginRecvInfo(plugin, message, payload));
break;
}
case PacketId.StreamMessages:
{
StreamQueue.Enqueue(message);
break;
}
case PacketId.LiteCode:
{
LiteCodeQueue.Enqueue(message);
break;
}
case PacketId.LiteCode_Delegates:
{
LiteCodeDelegateQueue.Enqueue(message);
break;
}
case PacketId.RequestMessages:
{
RequestQueue.Enqueue(message);
break;
}
}
this.stream.ReceiveState = ReceiveType.Header;
stream.Position += receivedSize;
payload = null;
}
else
{
DataAvailable = false;
}
break;
}
}
}
}
}
public abstract void onReceiveMessage(IPeerMessage message);