void SendActivationPacket(double preDelay = 0)
{
ProtocolPacket pkt = new ProtocolPacket();
pkt.SourceDeviceID = ActivatingId;
pkt.TimeToActivation = ActivateAt - CurrentTime - preDelay;
if (pkt.TimeToActivation > 0 && (PacketCount < PacketThreshold || MasterMode))
{
RadioTransmitPacket(pkt, preDelay);
}
PacketCount = 0;
MyPacketSpacing += PacketSpacingIncrease;
// Decide whether to send more packets.
double timetoEnd = ActivateAt - CurrentTime;
double thisPacketSpacing = MyPacketSpacing + ParentSimulation.NextRandom() * PacketRandomness;
if (timetoEnd < thisPacketSpacing)
{
SetTimerCallback(timetoEnd, () => Activate());
}
else
{
SetTimerCallback(thisPacketSpacing, () => SendActivationPacket());
}
}
/// <summary>
/// Called when a packet is received by this device.
/// </summary>
public void ReceivePacket(object packet)
{
ProtocolPacket pkt = (ProtocolPacket)packet;
if (WaitingForActivation)
{
// Do nothing- already aware of the impending activation
// Future: Deal with the possibility of two nodes being activated independently
PacketCount++;
}
else
{
// Imperfect computation - try to improve.
ActivateAt = CurrentTime + pkt.TimeToActivation;
ActivatingId = pkt.SourceDeviceID;
WaitingForActivation = true;
double delay = ParentSimulation.NextRandom() * PacketSpacing;
SetTimerCallback(delay, () => SendActivationPacket());
SetLedColor(Colors.Red);
PacketCount = 0;
MasterMode = false;
MyPacketSpacing = PacketSpacing;
RadioSetModeReceive();
}
}
public ReadPacketState(IClientEntry client,
ProtocolPacket packet, Exception exception)
{
Client = client;
Packet = packet;
Exception = exception;
}
public override void WritePacket(ProtocolPacket packet)
{
MemoryStream stm = new MemoryStream();
BinaryNetworkTransport.WritePacket(packet, new BinaryWriter(stm), false);
byte[] data = stm.ToArray();
_client.SendAsync(data, data.Length, _endpoint).GetAwaiter().GetResult();
}
public TargetProtocolPacket(IDataReader reader)
: this()
{
UserName = reader.ReadString();
ProtocolCommandId command = (ProtocolCommandId)reader.ReadInt32();
Packet = ProtocolPacket.FromData(command, reader);
}
private T GetMessageAs <T>(ProtocolPacket protocolPacket)
where T : class, IClientMessage
{
if (protocolPacket.Message is T message)
{
return(message);
}
throw new InvalidClientMessageException();
}
async Task <byte[]> IEasyChannel.SendAsync([NotNull] byte[] buffer, PacketOptions options, int millisecondsTimeout)
{
if (buffer is null)
{
throw new ArgumentNullException(nameof(buffer));
}
ProtocolPacket packet = CreatePacket(buffer, options);
return(await _easyBase.SendAsync(packet, ConnectOptions.RemoteEndPoint, millisecondsTimeout));
}
public bool WritePacket(ProtocolPacket packet)
{
try
{
_transport.WritePacket(packet);
return(true);
}
catch
{
return(false);
}
}
public void SetRequestSerialization()
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
Byte[] packet =
{
0x80, 0x01, 0x00, 0x05,
0x08, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x12,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x0e, 0x10,
0x48, 0x65, 0x6c, 0x6c,
0x6f, 0x57, 0x6f, 0x72,
0x6c, 0x64
};
writer.Write(packet);
stream.Seek(0, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(stream))
{
SetRequest request = (SetRequest)ProtocolPacket.ReadRequest(reader);
Assert.AreEqual(request.Header.Magic, 0x80);
Assert.AreEqual(request.Header.OpCode, CommandOpCode.Set);
Assert.AreEqual(request.Header.KeyLength, 5);
Assert.AreEqual(request.Header.ExtrasLength, 8);
Assert.AreEqual(request.Header.DataType, 0);
Assert.AreEqual(request.Header.Status, ResponseStatus.NoError);
Assert.AreEqual(request.Header.TotalBodyLength, (uint)0x12);
Assert.AreEqual(request.Header.Opaque, (uint)0);
Assert.AreEqual(request.Header.CAS, (ulong)0);
Assert.AreEqual(request.Header.Extras.Flags, (uint)0xdeadbeef);
Assert.AreEqual(request.Key, "Hello");
Assert.AreEqual(request.Value, "World");
MemoryStream stream2 = new MemoryStream();
BinaryWriter writer2 = new BinaryWriter(stream2);
request.Write(writer2);
writer.Close();
byte[] packet2 = stream2.ToArray();
CollectionAssert.AreEqual(packet, packet2);
}
}
public void SendMessage(IClientMessage message, bool compress = false, byte channel = 0, bool delay = true)
{
var protocolPacket = new ProtocolPacket(message, message.Type, compress, channel);
if (!delay)
{
SendPacket(protocolPacket);
}
else
{
_packetQueue.EnqueueOutgoing(protocolPacket);
}
}
public void GetRequestSerialization()
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
Byte[] packet =
{
0x80, 0x00, 0x00, 0x05,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x05,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x48, 0x65, 0x6c, 0x6c,
0x6f
};
writer.Write(packet);
stream.Seek(0, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(stream))
{
GetRequest request = (GetRequest)ProtocolPacket.ReadRequest(reader);
Assert.AreEqual(request.Header.Magic, 0x80);
Assert.AreEqual(request.Header.OpCode, CommandOpCode.Get);
Assert.AreEqual(request.Header.KeyLength, 5);
Assert.AreEqual(request.Header.ExtrasLength, 0);
Assert.AreEqual(request.Header.DataType, 0);
Assert.AreEqual(request.Header.Status, ResponseStatus.NoError);
Assert.AreEqual(request.Header.TotalBodyLength, (uint)5);
Assert.AreEqual(request.Header.Opaque, (uint)0);
Assert.AreEqual(request.Header.CAS, (ulong)0);
Assert.IsNull(request.Header.Extras);
Assert.AreEqual(request.Key, "Hello");
Assert.IsTrue(String.IsNullOrEmpty(request.Value));
MemoryStream stream2 = new MemoryStream();
BinaryWriter writer2 = new BinaryWriter(stream2);
request.Write(writer2);
writer.Close();
byte[] packet2 = stream2.ToArray();
CollectionAssert.AreEqual(packet, packet2);
}
}
public void GetResponseSerialization()
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
Byte[] packet =
{
0x81, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x09,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01,
0xde, 0xad, 0xbe, 0xef,
0x57, 0x6f, 0x72, 0x6c,
0x64
};
writer.Write(packet);
stream.Seek(0, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(stream))
{
GetResponse response = (GetResponse)ProtocolPacket.ReadRequest(reader);
Assert.AreEqual(response.Header.Magic, 0x81);
Assert.AreEqual(response.Header.OpCode, CommandOpCode.Get);
Assert.AreEqual(response.Header.KeyLength, 0);
Assert.AreEqual(response.Header.ExtrasLength, 4);
Assert.AreEqual(response.Header.DataType, 0);
Assert.AreEqual(response.Header.Status, ResponseStatus.NoError);
Assert.AreEqual(response.Header.TotalBodyLength, (uint)9);
Assert.AreEqual(response.Header.Opaque, (uint)0);
Assert.AreEqual(response.Header.CAS, (ulong)1);
Assert.AreEqual(response.Header.Extras.Flags, (uint)0xdeadbeef);
Assert.AreEqual(response.Value, "World");
Assert.IsTrue(String.IsNullOrEmpty(response.Key));
MemoryStream stream2 = new MemoryStream();
BinaryWriter writer2 = new BinaryWriter(stream2);
response.Write(writer2);
writer.Close();
byte[] packet2 = stream2.ToArray();
CollectionAssert.AreEqual(packet, packet2);
}
}
private ProtocolPacket CreatePacket(byte[] buffer, PacketOptions options)
{
ProtocolPacket packet = new ProtocolPacket
{
Ip = ((IPEndPoint)_tcpClient.Client.LocalEndPoint).Address.GetAddressBytes(),
Port = ((IPEndPoint)_tcpClient.Client.LocalEndPoint).Port,
Data = buffer,
PacketMode = PacketMode.Request,
IsCompress = options?.CompressBuffer ?? false,
HasResponse = options?.HasResponse ?? true,
ReportArrived = false
};
return(packet);
}
public bool WritePacket(ProtocolPacket packet)
{
try
{
MemoryStream stm = new MemoryStream();
BinaryNetworkTransport.WritePacket(packet, new BinaryWriter(stm), false);
byte[] data = stm.ToArray();
return(_listener._client.SendAsync(data, data.Length, _endpoint).GetAwaiter().GetResult() == data.Length);
}
catch (Exception)
{
Cancel();
return(false);
}
}
async Task <byte[]> IEasyHost.SendAsync([NotNull] byte[] buffer, PacketOptions options, int millisecondsTimeout)
{
if (buffer is null)
{
throw new ArgumentNullException(nameof(buffer));
}
ProtocolPacket packet = CreatePacket(buffer, options);
_tcpChannels.Keys.AsParallel().ForAll(async i =>
{
await i._easyBase.SendAsync(packet, ConnectOptions.RemoteEndPoint, millisecondsTimeout);
});
return(await Task.FromResult(new byte[0]));
}
public async Task <string> Get(String key, CommandOpCode opCode = CommandOpCode.Get)
{
GetRequest getRequest = new GetRequest(opCode);
getRequest.Key = key;
byte[] packet = getRequest.Serialize();
await this.stream.WriteAsync(packet, 0, packet.Length);
byte[] response = new byte[2048];
int bytesRead = await this.stream.ReadAsync(response, 0, response.Length);
GetResponse getResponse = (GetResponse)ProtocolPacket.Construct(response, 0, bytesRead);
return(getResponse.Value);
}
public async Task <ResponseStatus> Set(String key, String value, CommandOpCode opCode = CommandOpCode.Set)
{
SetRequest setRequest = new SetRequest(opCode);
setRequest.Key = key;
setRequest.Value = value;
byte[] packet = setRequest.Serialize();
await this.stream.WriteAsync(packet, 0, packet.Length);
byte[] response = new byte[2048];
int bytesRead = await this.stream.ReadAsync(response, 0, response.Length);
SetResponse setResponse = (SetResponse)ProtocolPacket.Construct(response, 0, bytesRead);
return(setResponse.Header.Status);
}
private void ProcessProtocolPacket(ProtocolPacket RXProtocolPacket)
{
Console.WriteLine("[{0}][{1}/{2}] From {3} to {4}", RXProtocolPacket.PacketMD5Sum, RXProtocolPacket.PacketCount, RXProtocolPacket.PacketTotal, RXProtocolPacket.SrcIP, RXProtocolPacket.DstIP);
if (ProtocolPacketPool.ContainsKey(RXProtocolPacket.PacketMD5Sum))
{
var ExistPacket = ProtocolPacketPool[RXProtocolPacket.PacketMD5Sum];
if (ExistPacket.PacketData[RXProtocolPacket.PacketCount] != RXProtocolPacket.PiecedMsg)
{
ExistPacket.PacketData[RXProtocolPacket.PacketCount] = RXProtocolPacket.PiecedMsg;
ExistPacket.PacketCount += 1;
}
if (ExistPacket.PacketCount == ExistPacket.PacketTotal)
{
var DataStr = "";
for (int i = 1; i <= ExistPacket.PacketTotal; i++)
{
DataStr += ExistPacket.PacketData[i];
}
Console.WriteLine("Full Msg[{0}] From {1} to {2}:\n{3}", ExistPacket.PacketMD5Sum, ExistPacket.SrcIP, ExistPacket.DstIP, DataStr);
RXData.Add(DataStr);
ProtocolPacketPool.Remove(ExistPacket.PacketMD5Sum);
}
}
else
{
RXProtocolPacket.PacketData = new string[RXProtocolPacket.PacketTotal + 1];
RXProtocolPacket.PacketData[RXProtocolPacket.PacketCount] = RXProtocolPacket.PiecedMsg;
RXProtocolPacket.PacketCount = 1;
ProtocolPacketPool.Add(RXProtocolPacket.PacketMD5Sum, RXProtocolPacket);
if (RXProtocolPacket.PacketCount == RXProtocolPacket.PacketTotal)
{
var DataStr = "";
for (int i = 1; i <= RXProtocolPacket.PacketTotal; i++)
{
DataStr += RXProtocolPacket.PacketData[i];
}
Console.WriteLine("Full Msg[{0}] From {1} to {2}:\n{3}", RXProtocolPacket.PacketMD5Sum, RXProtocolPacket.SrcIP, RXProtocolPacket.DstIP, DataStr);
RXData.Add(DataStr);
ProtocolPacketPool.Remove(RXProtocolPacket.PacketMD5Sum);
}
}
}
public async Task HandleHello(string username, bool supports_upgrade)
{
WritePacket(new HelloProtocolPacket(username, Environment.MachineName, supports_upgrade));
ProtocolPacket packet = await ReadPacket(3000);
if (packet.CommandId == ProtocolCommandId.Goodbye)
{
throw new EndOfStreamException(((GoodbyeProtocolPacket)packet).Message);
}
else if (packet.CommandId != ProtocolCommandId.ReKey)
{
throw new EndOfStreamException("Unknown packet response");
}
else
{
ReKeyProtocolPacket p = (ReKeyProtocolPacket)packet;
SetXorKey(p.XorKey);
}
}
static void HandlePacket(ProtocolPacket packet)
{
if (packet is MessageProtocolPacket)
{
MessageProtocolPacket p = packet as MessageProtocolPacket;
AddMessage(p.UserName, p.Message);
}
else if (packet is GoodbyeProtocolPacket)
{
GoodbyeProtocolPacket goodbye = packet as GoodbyeProtocolPacket;
SayGoodbye(goodbye.Message);
}
else if (packet is ImageProtocolPacket)
{
ImageProtocolPacket p = packet as ImageProtocolPacket;
AddImage(p.UserName, p.ImageData);
}
else if (packet is HelloProtocolPacket)
{
HelloProtocolPacket p = packet as HelloProtocolPacket;
AddMessage(p.UserName, String.Format("Hey I just joined from {0}!!11!", p.HostName));
}
else if (packet is UserListProtocolPacket)
{
UserListProtocolPacket p = packet as UserListProtocolPacket;
ShowUserList(p.UserList);
}
else if (packet is SendFileProtocolPacket)
{
Console.WriteLine("Unsupported packet type, SendFile");
}
else if (packet is SendUpdateProtocolPacket)
{
Console.WriteLine("Unsupported packet type, SendUpdate");
}
}
/// <summary>
/// Handle deserialized packets
/// </summary>
/// <param name="sender">the tcp connection taht received the packet</param>
/// <param name="packets">packet queue(queue will preserve order)</param>
public void OnPacketsReceived(object sender, Queue <ProtocolPacket> packets)
{
TcpConnection connection = (TcpConnection)sender;
while (packets.Count != 0)
{
ProtocolPacket packet = packets.Dequeue();
if (packet is GetRequest)
{
this.HandleGet(packet as GetRequest, connection);
}
else if (packet is SetRequest)
{
this.HandleSet(packet as SetRequest, connection);
}
else
{
Trace.TraceInformation("Unknown request {0}", packet.GetType().FullName);
}
}
}
static bool HandlePacket(ProtocolPacket packet)
{
switch (packet.CommandId)
{
case ProtocolCommandId.Message:
{
MessageProtocolPacket p = (MessageProtocolPacket)packet;
AddMessage(p.UserName, p.Message);
}
break;
case ProtocolCommandId.Goodbye:
{
GoodbyeProtocolPacket goodbye = (GoodbyeProtocolPacket)packet;
SayGoodbye(goodbye.Message);
return(true);
}
case ProtocolCommandId.Hello:
{
HelloProtocolPacket p = (HelloProtocolPacket)packet;
AddMessage(p.UserName, String.Format("Hey I just joined from {0}!!11!", p.HostName));
}
break;
case ProtocolCommandId.UserList:
{
UserListProtocolPacket p = (UserListProtocolPacket)packet;
ShowUserList(p.UserList);
}
break;
default:
Console.WriteLine("Unsupported packet type, {0}",
packet.CommandId);
break;
}
return(false);
}
static async Task <bool> WriteUdpPacket(UdpClient client, IPEndPoint endpoint, ProtocolPacket packet)
{
try
{
MemoryStream stm = new MemoryStream();
BinaryNetworkTransport.WritePacket(packet, new BinaryWriter(stm), false);
byte[] data = stm.ToArray();
int ret = await client.SendAsync(data, data.Length, endpoint);
return(ret == data.Length);
}
catch
{
return(false);
}
}
private void ProcessLoop()
{
var FakeMACAddr = System.Net.NetworkInformation.PhysicalAddress.Parse("90-90-90-90-90-90");
var Fakeethernetv4Packet = new PacketDotNet.EthernetPacket(FakeMACAddr, FakeMACAddr, PacketDotNet.EthernetPacketType.IPv4);
var Fakeethernetv6Packet = new PacketDotNet.EthernetPacket(FakeMACAddr, FakeMACAddr, PacketDotNet.EthernetPacketType.IPv6);
while (true)
{
var packet = rxBuffer.Take();
int IPversion = (packet.Data[0]) >> 4;
PacketDotNet.Packet ParsedPacket;
PacketDotNet.IPProtocolType IPNextProtocol;
switch (IPversion)
{
case 4:
var FullBytev4 = Fakeethernetv4Packet.Bytes.ToList();
FullBytev4.AddRange(packet.Data);
ParsedPacket = PacketDotNet.Packet.ParsePacket(PacketDotNet.LinkLayers.Ethernet, FullBytev4.ToArray()).PayloadPacket;
var IPv4Header = (PacketDotNet.IPv4Packet)ParsedPacket;
IPNextProtocol = IPv4Header.NextHeader;
ParsedPacket = IPv4Header.PayloadPacket;
break;
case 6:
var FullBytev6 = Fakeethernetv6Packet.Bytes.ToList();
FullBytev6.AddRange(packet.Data);
ParsedPacket = PacketDotNet.Packet.ParsePacket(PacketDotNet.LinkLayers.Ethernet, FullBytev6.ToArray()).PayloadPacket;
var IPv6Header = (PacketDotNet.IPv6Packet)ParsedPacket;
IPNextProtocol = IPv6Header.NextHeader;
ParsedPacket = IPv6Header.PayloadPacket;
break;
default:
txBuffer.Add(packet);
continue;
}
switch (IPNextProtocol)
{
case PacketDotNet.IPProtocolType.UDP:
break;
default:
txBuffer.Add(packet);
continue;
}
try
{
long nonceTime = (DateTimeOffset.Now.ToUnixTimeSeconds() / 300) * 300;
byte[] nonce = sha256Ctx.ComputeHash(Encoding.Default.GetBytes(nonceTime.ToString())).Take(8).ToArray();
byte[] decryptedData;
var NSecKey = Key.Import(AeadAlgorithm.ChaCha20Poly1305, key, KeyBlobFormat.RawSymmetricKey);
var NSecNonce = new Nonce(nonce, 4);
AeadAlgorithm.ChaCha20Poly1305.Decrypt(NSecKey, NSecNonce, null, ParsedPacket.PayloadData, out decryptedData);
if (decryptedData == null)
{
// Data will be null when decrypt failed, this may mean the packet is not sended by this software.
txBuffer.Add(packet);
continue;
}
ProtocolPacket RXProtocolPacket = JsonConvert.DeserializeObject <ProtocolPacket>(System.Text.Encoding.Default.GetString(decryptedData));
if (RXProtocolPacket.PacketMD5Sum == "")
{
continue;
}
ProcessProtocolPacket(RXProtocolPacket);
}
catch (Exception ex)
{
// This will not catch decrypt fail, but may catch other erros likes key format error.
Console.WriteLine(ex);
txBuffer.Add(packet);
}
}
}
private void Send()
{
while (true)
{
string input = TXData.Take();
if (input == "")
{
continue;
}
var Timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
var MD5Sum = BitConverter.ToString(sha256Ctx.ComputeHash(System.Text.Encoding.Default.GetBytes(input + rand.Next(0, 65536).ToString()))).Replace("-", "");
Stack <string> PiecedMsg = new Stack <string>();
while (input.Length > 0)
{
if (input.Length <= 5)
{
PiecedMsg.Push(input);
input = "";
}
else
{
var cutlen = rand.Next(0, input.Length);
PiecedMsg.Push(input.Substring(0, cutlen));
input = input.Substring(cutlen);
}
}
var PacketTotal = PiecedMsg.Count;
while (PiecedMsg.Count > 0)
{
IPAddress SrcIP, DstIP;
switch (rand.Next(0, 2))
{
case 0:
if (IPv6SrcList.Count != 0 && IPv6DstList.Count != 0)
{
DstIP = IPv6DstList[rand.Next(0, IPv6DstList.Count)];
SrcIP = IPv6SrcList[rand.Next(0, IPv6SrcList.Count)];
}
else
{
DstIP = IPv4DstList[rand.Next(0, IPv4DstList.Count)];
SrcIP = IPv4SrcList[rand.Next(0, IPv4SrcList.Count)];
}
break;
default:
if (IPv4SrcList.Count != 0 && IPv4DstList.Count != 0)
{
DstIP = IPv4DstList[rand.Next(0, IPv4DstList.Count)];
SrcIP = IPv4SrcList[rand.Next(0, IPv4SrcList.Count)];
}
else
{
DstIP = IPv6DstList[rand.Next(0, IPv6DstList.Count)];
SrcIP = IPv6SrcList[rand.Next(0, IPv6SrcList.Count)];
}
break;
}
var TXProtocolPacket = new ProtocolPacket {
PacketTimestamp = Timestamp, PacketTotal = PacketTotal, PacketMD5Sum = MD5Sum, PacketCount = PiecedMsg.Count, SrcIP = SrcIP.ToString(), DstIP = DstIP.ToString()
};
TXProtocolPacket.PiecedMsg = PiecedMsg.Pop();
var udpPacket = new PacketDotNet.UdpPacket((ushort)rand.Next(1, 65536), (ushort)rand.Next(1, 65536));
long nonceTime = (DateTimeOffset.Now.ToUnixTimeSeconds() / 300) * 300;
byte[] nonce = sha256Ctx.ComputeHash(System.Text.Encoding.Default.GetBytes(nonceTime.ToString())).Take(8).ToArray();
var NSecKey = Key.Import(AeadAlgorithm.ChaCha20Poly1305, key, KeyBlobFormat.RawSymmetricKey);
var NSecNonce = new Nonce(nonce, 4);
udpPacket.PayloadData = AeadAlgorithm.ChaCha20Poly1305.Encrypt(NSecKey, NSecNonce, null, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(TXProtocolPacket)));
if (DstIP.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
var ipv4Packet = new PacketDotNet.IPv4Packet(SrcIP, DstIP);
ipv4Packet.PayloadPacket = udpPacket;
udpPacket.UpdateCalculatedValues();
udpPacket.UpdateUDPChecksum();
ipv4Packet.UpdateCalculatedValues();
txBuffer.Add(new DivertPacket {
Addr = new WINDIVERT_ADDRESS {
Direction = 0
}, Data = ipv4Packet.Bytes
});
}
if (DstIP.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
var ipv6Packet = new PacketDotNet.IPv6Packet(SrcIP, DstIP);
ipv6Packet.NextHeader = PacketDotNet.IPProtocolType.UDP;
ipv6Packet.PayloadPacket = udpPacket;
udpPacket.UpdateCalculatedValues();
udpPacket.UpdateUDPChecksum();
ipv6Packet.UpdateCalculatedValues();
txBuffer.Add(new DivertPacket {
Addr = new WINDIVERT_ADDRESS {
Direction = 0
}, Data = ipv6Packet.Bytes
});
}
}
}
}
/// <summary>
/// This method will perform the packet framing. Each time we receive data on the
/// socket, we peel off packets fro mit and remember the remaining data. This handles
/// partial packets including partial headers.
/// </summary>
/// <param name="data">data received on the socket</param>
/// <param name="start">start</param>
/// <param name="length">number of bytes</param>
public void Push(byte[] data, int start, int length)
{
// If we have pending data, append the new data to it.
if (this.pendingByteCount != 0)
{
data = Utilities.Utilities.Combine(this.workingBuffer, data);
this.workingBuffer = null;
this.pendingByteCount = 0;
}
using (MemoryStream memoryStream = new MemoryStream(data, start, length))
{
using (BinaryReader reader = new BinaryReader(memoryStream))
{
int remainingBytes = (int)(memoryStream.Length - memoryStream.Position);
while (remainingBytes > ProtocolHeader.HeaderLength)
{
ProtocolHeader header = null;
// If we already have a header, use it. If not read a new one.
if (this.pendingHeader != null)
{
header = this.pendingHeader;
this.pendingHeader = null;
}
else
{
header = new ProtocolHeader();
header.Read(reader);
}
remainingBytes = (int)(memoryStream.Length - memoryStream.Position);
if (header.TotalBodyLength - header.ExtrasLength <= remainingBytes)
{
// At this point, we have a full packet. Queue it for consumption
ProtocolPacket packet = ProtocolPacket.ReadRequest(reader, header);
this.Packets.Enqueue(packet);
}
else
{
// We have a header and a partial body. Save it for later.
this.pendingHeader = header;
this.workingBuffer = reader.ReadBytes(remainingBytes);
this.pendingByteCount = remainingBytes;
}
remainingBytes = (int)(memoryStream.Length - memoryStream.Position);
}
// We might have a partial header left out. Store the bytes till we get the next packet
remainingBytes = (int)(memoryStream.Length - memoryStream.Position);
if (remainingBytes != 0)
{
this.workingBuffer = reader.ReadBytes(remainingBytes);
this.pendingByteCount = remainingBytes;
this.pendingHeader = null;
}
}
}
}
private bool DecodePacket(BufferData data, out ushort length)
{
using (var br = data.GetReader(data.Offset, data.RemainingLength))
{
var rawPacket = new ProtocolPacket();
rawPacket.Read(br);
if (rawPacket.Channel != 0)
{
if (rawPacket.SequenceNumber < ReceiveSequence[rawPacket.Channel])
{
Debugger.Break();
length = rawPacket.Size; // throw away the packet
return(true);
}
ReceiveSequence[rawPacket.Channel] = rawPacket.SequenceNumber;
}
length = rawPacket.Size;
data.Offset += (int)br.BaseStream.Position;
if (rawPacket.Type == ClientMessageOpcode.None)
{
if (length != 4)
{
Debugger.Break(); // If it's not send timeout check, let's investigate...
}
return(true);
}
_packetQueue.EnqueueIncoming(rawPacket);
}
/*var packet = new PythonCallPacket(length);
* using (var br = data.GetReader())
* {
* packet.Read(br);
*
* if (packet.Return.HasValue)
* return packet.Return.Value;
*
* if (packet.Type == 2)
* {
* State = ClientState.LoggedIn;
* Entry = Server.AuthenticateClient(this, packet.AccountId, packet.OneTimeKey);
* if (Entry == null)
* {
* Logger.WriteLog(LogType.Error, "Client with ip: {0} tried to log in with invalid session data! User Id: {1} | OneTimeKey: {2}", Socket.RemoteAddress, packet.AccountId, packet.OneTimeKey);
* Close(false);
* return false;
* }
*
* CharacterManager.Instance.StartCharacterSelection(this);
* return true;
* }
*
* if (packet.DataSize > 0 && br.BaseStream.Position + packet.DataSize < br.BaseStream.Length)
* {
* if (br.ReadByte() != 0x4F) // 'O' format
* throw new Exception("Unsupported serialization format!");
*
* var packetType = PacketRouter.GetPacketType(packet.Opcode);
* if (packetType != null)
* {
* var pythonPacket = Activator.CreateInstance(packetType) as IBasePacket;
* if (pythonPacket == null)
* return false;
*
* pythonPacket.Read(br);
*
* Server.PacketQueue.EnqueueIncoming(this, pythonPacket);
* }
* else
* Logger.WriteLog(LogType.Error, $"Unhandled game opcode: {packet.Opcode}");
* }
* else
* Logger.WriteLog(LogType.Error, $"Invalid data found in Python method call! Off: {br.BaseStream.Position} | Len: {packet.DataSize} | Array len: {br.BaseStream.Length}");
* }*/
return(true);
}
private void HandleProtocolPacket(ProtocolPacket protocolPacket)
{
switch (protocolPacket.Type)
{
case ClientMessageOpcode.Login:
var loginMsg = GetMessageAs <LoginMessage>(protocolPacket);
if (loginMsg.Version.Length != 8 || loginMsg.Version != "1.16.5.0")
{
Logger.WriteLog(LogType.Error, $"Client version mismatch: Server: 1.16.5.0 | Client: {loginMsg.Version}");
SendMessage(new LoginResponseMessage
{
ErrorCode = LoginErrorCodes.VersionMismatch,
Subtype = LoginResponseMessageSubtype.Failed
}, delay: false);
return;
}
var loginEntry = Server.AuthenticateClient(this, loginMsg.AccountId, loginMsg.OneTimeKey);
if (loginEntry == null)
{
Logger.WriteLog(LogType.Error, "Client with ip: {0} tried to log in with invalid session data! User Id: {1} | OneTimeKey: {2}", Socket.RemoteAddress, loginMsg.AccountId,
loginMsg.OneTimeKey);
SendMessage(new LoginResponseMessage
{
ErrorCode = LoginErrorCodes.AuthenticationFailed,
Subtype = LoginResponseMessageSubtype.Failed
}, delay: false);
return;
}
using (var unitOfWork = _gameUnitOfWorkFactory.CreateChar())
{
unitOfWork.GameAccounts.CreateOrUpdate(loginEntry.Id, loginEntry.Name, loginEntry.Email);
if (Server.IsBanned(loginMsg.AccountId))
{
Logger.WriteLog(LogType.Error, "Client with ip: {0} tried to log in while the account is banned! User Id: {1}", Socket.RemoteAddress, loginMsg.AccountId);
SendMessage(new LoginResponseMessage
{
ErrorCode = LoginErrorCodes.AccountLocked,
Subtype = LoginResponseMessageSubtype.Failed
}, delay: false);
return;
}
if (Server.IsAlreadyLoggedIn(loginMsg.AccountId))
{
Logger.WriteLog(LogType.Error, "Client with ip: {0} tried to log in while the account is being played on! User Id: {1}", Socket.RemoteAddress, loginMsg.AccountId);
SendMessage(new LoginResponseMessage
{
ErrorCode = LoginErrorCodes.AlreadyLoggedIn,
Subtype = LoginResponseMessageSubtype.Failed
}, delay: false);
return;
}
LoadGameAccountEntry(unitOfWork, loginEntry.Id);
unitOfWork.GameAccounts.UpdateLoginData(loginEntry.Id, Socket.RemoteAddress);
unitOfWork.Complete();
}
SendMessage(new LoginResponseMessage
{
AccountId = loginMsg.AccountId,
Subtype = LoginResponseMessageSubtype.Success
});
State = ClientState.LoggedIn;
_characterManager.StartCharacterSelection(this);
return;
case ClientMessageOpcode.Move:
if (Player == null)
{
return;
}
var moveMessage = GetMessageAs <MoveMessage>(protocolPacket);
if (moveMessage.Movement == null)
{
return;
}
Player.Position = moveMessage.Movement.Position;
Player.Rotation = moveMessage.Movement.ViewDirection.X;
break;
case ClientMessageOpcode.CallServerMethod:
var csmPacket = GetMessageAs <CallServerMethodMessage>(protocolPacket);
if (!csmPacket.ReadPacket())
{
Close(true);
return;
}
PacketRouter.RoutePacket(_handler, csmPacket.Packet);
break;
case ClientMessageOpcode.Ping:
var pingMessage = GetMessageAs <PingMessage>(protocolPacket);
SendMessage(pingMessage, delay: false);
break;
}
}
public override void WritePacket(ProtocolPacket packet)
{
_transport.WritePacket(packet);
}
// Return false if the connection should be closed.
static bool HandlePacket(IClientEntry client, IEnumerable <IClientEntry> other_clients, ProtocolPacket packet)
{
bool result = true;
ProtocolPacket write_packet = null;
switch (packet.CommandId)
{
case ProtocolCommandId.Hello:
{
HelloProtocolPacket hello = (HelloProtocolPacket)packet;
Console.WriteLine("Hello Packet for User: {0} HostName: {1}", hello.UserName, hello.HostName);
client.UserName = hello.UserName;
client.HostName = hello.HostName;
ReKeyProtocolPacket rekey = new ReKeyProtocolPacket();
if (hello.SupportsSecurityUpgrade)
{
Random r = new Random();
rekey.XorKey = (byte)r.Next(256);
}
result = client.WritePacket(rekey);
client.SetXorKey(rekey.XorKey);
write_packet = new MessageProtocolPacket(hello.UserName,
String.Format("I've just joined from {0}", hello.HostName));
}
break;
case ProtocolCommandId.Message:
write_packet = packet;
break;
case ProtocolCommandId.GetUserList:
result = client.WritePacket(new UserListProtocolPacket(other_clients.
Where(c => c.UserName != null && c.HostName != null).Select(c => new UserListEntry(c.UserName, c.HostName))));
break;
case ProtocolCommandId.Target:
{
TargetProtocolPacket target = (TargetProtocolPacket)packet;
IClientEntry target_client = other_clients.Where(c => c.UserName.Equals(target.UserName)).FirstOrDefault();
if (target_client != null)
{
result = target_client.WritePacket(target.Packet);
}
}
break;
case ProtocolCommandId.Goodbye:
client.WritePacket(new GoodbyeProtocolPacket("Don't let the door hit you on the way out!"));
if (!String.IsNullOrEmpty(client.UserName))
{
GoodbyeProtocolPacket goodbye = (GoodbyeProtocolPacket)packet;
write_packet = new MessageProtocolPacket("Server", String.Format("'{0}' has quit, they said '{1}'", client.UserName, goodbye.Message));
}
result = false;
break;
case ProtocolCommandId.Ping:
break;
}
if (write_packet != null)
{
foreach (IClientEntry entry in other_clients)
{
entry.WritePacket(write_packet);
}
}
return(result);
}
