public void Process()
{
while (m_socket.Available > 0)
{
int size = m_in.Length;
size += m_socket.Receive(m_in.GetBuffer(), size, m_in.Capacity - size, SocketFlags.None);
m_in.Position = 0;
m_in.SetLength(size);
PickMsg();
}
PickMsg();
FlushSending();
}
public int Receive(byte[] buffer, int offset, int _size, SocketFlags flags)
{
int size = m_receiveStream.Length - m_receiveStream.Position;
Array.Copy(m_receiveStream.GetBuffer(), m_receiveStream.Position, buffer, offset, size);
m_receiveStream.Position = 0;
m_receiveStream.SetLength(0);
return(size);
}
public void Test()
{
var bs = new BinaryStream();
bs.WriteAddress(new IPEndPoint(IPAddress.Parse("192.168.1.10"), 19132));
Assert.Equal(bs.GetBuffer(), new byte[7] {
0x04, 0x3f, 0x57, 0xfe, 0xf5, 0xbc, 0x4a
});
bs.Clear();
bs.WriteAddress(new IPEndPoint(IPAddress.Parse("2404:6800:4004:0810:0000:0000:0000:2004"), 19132));
Assert.Equal(bs.GetBuffer(), new byte[21]
{
0x06,
0x17, 0x00,
0xbc, 0x4a,
0x24, 0x04, 0x68, 0x00, 0x40, 0x04, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x04
});
}
public void Test()
{
var bs = new BinaryStream();
new UnconnectedPong
{
Timestamp = 0x0123456789ff,
PongId = 1,
Magic = Constants.Magic,
ServerInfo = "MCBEProtocol Test Server"
}.Encode(bs);
Assert.Equal(bs.GetBuffer(), new byte[]
{
// Timestamp
0xff, 0x89, 0x67, 0x45, 0x23, 0x01, 0x00, 0x00,
// PongId
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Magic
0x00, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0x12, 0x34, 0x56, 0x78,
// ServerName Length
0x18, 0x00,
// ServerName
0x4d, 0x43, 0x42, 0x45, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72
});
bs.Clear();
new UnconnectedPing
{
Timestamp = 0x0123456789ff,
Magic = Constants.Magic,
ClientId = 0xfedcba98765432
}.Encode(bs);
Assert.Equal(bs.GetBuffer(), new byte[]
{
// Timestamp
0xff, 0x89, 0x67, 0x45, 0x23, 0x01, 0x00, 0x00,
// Magic
0x00, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0x12, 0x34, 0x56, 0x78,
// ClientId
0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe, 0x00
});
bs.Clear();
}
public byte[] Encode()
{
BinaryStream stream = new BinaryStream();
stream.WriteByte((byte)((byte)Reliability << 4 | (IsSplit ? 1 : 0)));
stream.WriteUInt(MessageId, ByteOrder.Little);
stream.WriteUShort(SplitId, ByteOrder.Little);
stream.WriteUShort(SplitIndex, ByteOrder.Little);
stream.WriteUShort(LastSplitIndex, ByteOrder.Little);
stream.WriteUShort((ushort)Payload.Length, ByteOrder.Little);
stream.WriteBytes(Payload);
return(stream.GetBuffer());
}
public void FlushSending()
{
if (m_out.Length > 0)
{
try
{
m_socket.Send(m_out.GetBuffer(), 0, m_out.Length, SocketFlags.None);
m_out.Position = 0;
m_out.SetLength(0);
}
catch (Exception e)
{
Console.WriteLine("Send failed! {0}" + e.Message);
}
}
}
public override void DecodePayload()
{
LoginData = new LoginData();
ClientData = new ClientData();
Protocol = ReadInt();
int len = ReadVarInt();
using (BinaryStream stream = new BinaryStream(ReadBytes(len)))
{
int loginDataLen = stream.ReadInt(ByteOrder.Little);
ReadLoginData(stream.ReadBytes(loginDataLen));
int clientDataLen = stream.ReadInt(ByteOrder.Little);
ReadClientData(stream.ReadBytes(clientDataLen));
WriteBytes(stream.GetBuffer());
}
}
public static void Main(string[] args)
{
if (args.Length > 0 && args[0] == "server")
{
_client = new ReliabilityUdpClient(new IPEndPoint(IPAddress.Any, 6000), data => { }, ReceiveServer);
_client.Listen();
}
else
{
_client = new ReliabilityUdpClient(new IPEndPoint(IPAddress.Any, 0), Connection, ReceiveClient);
_client.Listen();
bool b = _client.ConnectionAsync(new IPEndPoint(IPAddress.Parse("133.167.115.186"), 6000)).Result;
if (!b)
{
Console.WriteLine("Connection Error");
return;
}
}
while (true)
{
string chat = Console.ReadLine();
if (chat == "%exit")
{
break;
}
using (BinaryStream stream = new BinaryStream())
{
stream.WriteByte(1);
stream.WriteStringUtf8(chat);
foreach (var session in _client.GetSessions())
{
session.SendPacket(new CustomDataPacket(stream.GetBuffer()));
}
}
}
}
private void LoadLanguages()
{
if (!string.IsNullOrWhiteSpace(_folder))
{
_languageFiles.Clear();
_files.Clear();
_directoryInfo = new DirectoryInfo(_folder);
if (_directoryInfo.Exists)
{
BinaryStream stream = new BinaryStream();
stream.WriteStringUtf8(_folder);
File.WriteAllBytes("Data_00.bin", stream.GetBuffer());
foreach (FileInfo fileInfo in _directoryInfo.GetFiles("*.json"))
{
LanguageFile languageFile = new LanguageFile(fileInfo);
_languageFiles.Add(languageFile.GetCulture(), languageFile);
_files.Add(languageFile.GetCulture(), fileInfo);
}
}
}
}
public void OnReceive(DataPacket dataPacket)
{
AckPacket packet = new AckPacket(new[] { dataPacket.SequenceId });
_client.Send(EndPoint, packet);
if (dataPacket.SequenceId > ReceiveSequenceId)
{
uint seq = dataPacket.SequenceId - ReceiveSequenceId;
for (uint i = 0; i < seq; i++)
{
NackPacket nackPacket = new NackPacket(new[] { dataPacket.SequenceId - i - 1 });
_client.Send(EndPoint, nackPacket);
}
}
if (dataPacket.SequenceId >= ReceiveSequenceId)
{
ReceiveSequenceId = dataPacket.SequenceId + 1;
}
EncapsulatedPacket encapsulatedPacket = new EncapsulatedPacket();
encapsulatedPacket.Decode(dataPacket.Data);
if (encapsulatedPacket.IsSplit)
{
if (!SplitsPackets.ContainsKey(encapsulatedPacket.SplitId))
{
SplitsPackets[encapsulatedPacket.SplitId] =
new List <EncapsulatedPacket>();
}
SplitsPackets[encapsulatedPacket.SplitId].Add(encapsulatedPacket);
if (SplitsPackets[encapsulatedPacket.SplitId].Count == encapsulatedPacket.LastSplitIndex + 1)
{
SplitsPackets[encapsulatedPacket.SplitId].Sort(Comparison);
BinaryStream stream = new BinaryStream();
foreach (var splitsPacket in SplitsPackets[encapsulatedPacket.SplitId])
{
stream.WriteBytes(splitsPacket.Payload);
}
SplitsPackets.Remove(encapsulatedPacket.SplitId);
encapsulatedPacket = new EncapsulatedPacket(encapsulatedPacket.Reliability,
encapsulatedPacket.MessageId, stream.GetBuffer());
}
else
{
return;
}
}
if (!MessageWindow.Contains(encapsulatedPacket.MessageId))
{
if (MessageWindow.Count >= 50)
{
MessageWindow.RemoveAt(0);
}
MessageWindow.Add(encapsulatedPacket.MessageId);
OnEncapsulatedPacket(encapsulatedPacket);
}
}
public int Send(byte[] buf, int offset, int size, SocketFlags flags)
{
Array.Copy(buf, offset, m_sendStream.GetBuffer(), m_sendStream.Position, size);
m_sendStream.SetLength(m_sendStream.Length + size);
return(size);
}
