static void Main(string[] args)
{
//MinetAnvilTest test = new MinetAnvilTest();
//test.LoadFullAnvilRegionLoadTest();
/*MinetServerTest tests = new MinetServerTest();
* tests.HighPrecTimerSignalingLoadTest();
* System.Console.WriteLine("Running ...");
*
* System.Console.WriteLine("<Enter> to ABORT");
* System.Console.ReadLine();
* tests.cancel.Cancel();
*
* tests.PrintResults();
*
* System.Console.WriteLine("<Enter> to exit");
* System.Console.ReadLine();*/
var hex = "7ce74296b1120000330000001e0200000000803f0000803fa8ce84b97ce74296";
var bytes = Enumerable.Range(0, hex.Length)
.Where(x => x % 2 == 0)
.Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
.ToArray();
var t = (McpePlaySound)PackageFactory.CreatePackage(0x56, bytes, "mcpe");
System.Console.WriteLine(t.coordinates + ", " + t.name + ", " + t.pitch);
System.Console.ReadLine();
}
public Orders()
{
Response = System.Web.HttpContext.Current.Response;
Request = System.Web.HttpContext.Current.Request;
Server = System.Web.HttpContext.Current.Server;
Session = System.Web.HttpContext.Current.Session;
Application = System.Web.HttpContext.Current.Application;
tools = ToolsFactory.CreateTools();
encrypt = EncryptFactory.CreateEncrypt();
MyOrders = OrdersFactory.CreateOrders();
Mylog = OrdersLogFactory.CreateOrdersLog();
MyDelivery = DeliveryWayFactory.CreateDeliveryWay();
MyPayway = PayWayFactory.CreatePayWay();
MyProduct = ProductFactory.CreateProduct();
Mypackage = PackageFactory.CreatePackage();
Myorderdelivery = OrdersDeliveryFactory.CreateOrdersDelivery();
MyFavorFee = PromotionFavorFeeFactory.CreatePromotionFavorFee();
MyCoupon = PromotionFavorCouponFactory.CreatePromotionFavorCoupon();
MyBack = OrdersBackApplyFactory.CreateOrdersBackApply();
MyPolicy = PromotionFavorPolicyFactory.CreatePromotionFavorPolicy();
MySupplier = SupplierFactory.CreateSupplier();
Mydelierytime = DeliveryTimeFactory.CreateDeliveryTime();
MyMember = MemberFactory.CreateMember();
MyConsumption = MemberConsumptionFactory.CreateMemberConsumption();
pageurl = new PageURL(int.Parse(Application["Static_IsEnable"].ToString()));
MyAccountLog = MemberAccountLogFactory.CreateMemberAccountLog();
MyFavor = PromotionFavorFactory.CreatePromotionFavor();
MyCouponRule = PromotionCouponRuleFactory.CreatePromotionFavorCoupon();
MyInvoice = OrdersInvoiceFactory.CreateOrdersInvoice();
}
private void HandleSplitMessage(PlayerNetworkSession playerSession, ConnectedPackage package, SplitPartPackage splitMessage, Player player)
{
int spId = package._splitPacketId;
int spIdx = package._splitPacketIndex;
int spCount = package._splitPacketCount;
if (!playerSession.Splits.ContainsKey(spId))
{
playerSession.Splits.TryAdd(spId, new SplitPartPackage[spCount]);
}
SplitPartPackage[] spPackets = playerSession.Splits[spId];
spPackets[spIdx] = splitMessage;
bool haveEmpty = false;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
SplitPartPackage[] waste;
playerSession.Splits.TryRemove(spId, out waste);
MemoryStream stream = new MemoryStream();
for (int i = 0; i < spPackets.Length; i++)
{
SplitPartPackage splitPartPackage = spPackets[i];
byte[] buf = splitPartPackage.Message;
if (buf == null)
{
Log.Error("Expected bytes in splitpart, but got none");
continue;
}
stream.Write(buf, 0, buf.Length);
splitPartPackage.PutPool();
}
byte[] buffer = stream.ToArray();
try
{
Package fullMessage = PackageFactory.CreatePackage(buffer[0], buffer) ?? new UnknownPackage(buffer[0], buffer);
fullMessage.DatagramSequenceNumber = package._datagramSequenceNumber;
fullMessage.ReliableMessageNumber = package._reliableMessageNumber;
fullMessage.OrderingChannel = package._orderingChannel;
fullMessage.OrderingIndex = package._orderingIndex;
HandlePackage(fullMessage, playerSession);
fullMessage.PutPool();
}
catch (Exception e)
{
player.Disconnect("Bad package received from client.");
}
}
}
public Cart()
{
Response = System.Web.HttpContext.Current.Response;
Request = System.Web.HttpContext.Current.Request;
Server = System.Web.HttpContext.Current.Server;
Session = System.Web.HttpContext.Current.Session;
Application = System.Web.HttpContext.Current.Application;
tools = ToolsFactory.CreateTools();
encrypt = EncryptFactory.CreateEncrypt();
MyOrders = OrdersFactory.CreateOrders();
MyCart = OrdersGoodsTmpFactory.CreateOrdersGoodsTmp();
MyProduct = ProductFactory.CreateProduct();
MyMem = MemberFactory.CreateMember();
Mypackage = PackageFactory.CreatePackage();
MyAddr = MemberAddressFactory.CreateMemberAddress();
MyDelivery = DeliveryWayFactory.CreateDeliveryWay();
MyPayway = PayWayFactory.CreatePayWay();
Mydelierytime = DeliveryTimeFactory.CreateDeliveryTime();
MyInvioce = OrdersInvoiceFactory.CreateOrdersInvoice();
MyFavorFee = PromotionFavorFeeFactory.CreatePromotionFavorFee();
MyCoupon = PromotionFavorCouponFactory.CreatePromotionFavorCoupon();
MyPolicy = PromotionFavorPolicyFactory.CreatePromotionFavorPolicy();
MyGift = PromotionFavorGiftFactory.CreatePromotionFavorGift();
MyCommission = SupplierCommissionCategoryFactory.CreateSupplierCommissionCategory();
MySupplier = SupplierFactory.CreateSupplier();
MyFavor = PromotionFavorFactory.CreatePromotionFavor();
MyLimit = PromotionLimitFactory.CreatePromotionLimit();
MyMemberFavor = MemberFavoritesFactory.CreateMemberFavorites();
pageurl = new PageURL(int.Parse(Application["Static_IsEnable"].ToString()));
}
public Member()
{
Response = System.Web.HttpContext.Current.Response;
Request = System.Web.HttpContext.Current.Request;
Server = System.Web.HttpContext.Current.Server;
Session = System.Web.HttpContext.Current.Session;
Application = System.Web.HttpContext.Current.Application;
tools = ToolsFactory.CreateTools();
MyMember = MemberFactory.CreateMember();
Mygrade = MemberGradeFactory.CreateMemberGrade();
MyMemLog = MemberLogFactory.CreateMemberLog();
encrypt = EncryptFactory.CreateEncrypt();
MyConsumption = MemberConsumptionFactory.CreateMemberConsumption();
MyFavor = MemberFavoritesFactory.CreateMemberFavorites();
MyProduct = ProductFactory.CreateProduct();
MyPackage = PackageFactory.CreatePackage();
MyReview = ProductReviewFactory.CreateProductReview();
MyFeedback = FeedBackFactory.CreateFeedBack();
MyAddr = MemberAddressFactory.CreateMemberAddress();
MyCart = OrdersGoodsTmpFactory.CreateOrdersGoodsTmp();
MyCoupon = PromotionFavorCouponFactory.CreatePromotionFavorCoupon();
// MyEmail = U_EmailNotifyRequestFactory.CreateU_EmailNotifyRequest();
MyAccountLog = MemberAccountLogFactory.CreateMemberAccountLog();
MyShop = SupplierShopFactory.CreateSupplierShop();
pageurl = new PageURL(int.Parse(Application["Static_IsEnable"].ToString()));
}
private void HandleSplitMessage(PlayerNetworkSession playerSession, ConnectedPackage package, SplitPartPackage splitMessage)
{
int spId = package._splitPacketId;
int spIdx = package._splitPacketIndex;
int spCount = package._splitPacketCount;
if (!playerSession.Splits.ContainsKey(spId))
{
playerSession.Splits.TryAdd(spId, new SplitPartPackage[spCount]);
}
SplitPartPackage[] spPackets = playerSession.Splits[spId];
spPackets[spIdx] = splitMessage;
bool haveEmpty = false;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
SplitPartPackage[] waste;
playerSession.Splits.TryRemove(spId, out waste);
MemoryStream stream = new MemoryStream();
for (int i = 0; i < spPackets.Length; i++)
{
SplitPartPackage splitPartPackage = spPackets[i];
byte[] buf = splitPartPackage.Message;
stream.Write(buf, 0, buf.Length);
splitPartPackage.PutPool();
}
byte[] buffer = stream.ToArray();
byte id = buffer[0];
if (id == 0x8e)
{
id = buffer[1];
}
Package fullMessage = PackageFactory.CreatePackage(id, buffer) ?? new UnknownPackage(id, buffer);
fullMessage.DatagramSequenceNumber = package._datagramSequenceNumber;
fullMessage.OrderingChannel = package._orderingChannel;
fullMessage.OrderingIndex = package._orderingIndex;
if (!(fullMessage is McpeBatch))
{
Log.Debug($"Split: {fullMessage.GetType().Name} 0x{fullMessage.Id:x2} \n{Package.HexDump(buffer)}");
}
HandlePackage(fullMessage);
fullMessage.PutPool();
}
}
internal void HandlePackage(Package message, PlayerNetworkSession playerSession)
{
if (message == null)
{
return;
}
TraceReceive(message);
if (typeof(UnknownPackage) == message.GetType())
{
return;
}
if (typeof(McpeBatch) == message.GetType())
{
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
byte[] internalBuffer = destination.ToArray();
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
}
foreach (var msg in messages)
{
msg.DatagramSequenceNumber = batch.DatagramSequenceNumber;
msg.OrderingChannel = batch.OrderingChannel;
msg.OrderingIndex = batch.OrderingIndex;
HandlePackage(msg, playerSession);
msg.PutPool();
}
return;
}
message.Source = "HandlePackage";
Player player = playerSession.Player;
if (player != null)
{
player.HandlePackage(message);
}
}
public Package()
{
//初始化ASP.NET内置对象
Response = System.Web.HttpContext.Current.Response;
Request = System.Web.HttpContext.Current.Request;
Server = System.Web.HttpContext.Current.Server;
Session = System.Web.HttpContext.Current.Session;
Application = System.Web.HttpContext.Current.Application;
tools = ToolsFactory.CreateTools();
MyBLL = PackageFactory.CreatePackage();
MyBLLPRO = ProductFactory.CreateProduct();
MyProduct = new Product();
}
/// <summary>
/// Handles the specified package.
/// </summary>
/// <param name="message">The package.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
private void HandlePackage(Package message, PlayerNetworkSession playerSession)
{
TraceReceive(message);
if (typeof(UnknownPackage) == message.GetType())
{
return;
}
if (typeof(McpeBatch) == message.GetType())
{
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
byte[] internalBuffer = destination.ToArray();
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
}
foreach (var msg in messages)
{
HandlePackage(msg, playerSession);
}
}
playerSession.Player.HandlePackage(message);
playerSession.LastUpdatedTime = DateTime.UtcNow;
if (typeof(DisconnectionNotification) == message.GetType())
{
PlayerNetworkSession value;
_playerSessions.TryRemove(playerSession.EndPoint, out value);
}
}
private void OnBatch(Package message)
{
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
destination.Position = 0;
NbtBinaryReader reader = new NbtBinaryReader(destination, true);
do
{
int len = reader.ReadInt32();
byte[] internalBuffer = reader.ReadBytes(len);
var package = PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer);
messages.Add(package);
if (!(package is McpeFullChunkData))
{
Log.Debug($"Batch: {package.GetType().Name} 0x{package.Id:x2} \n{Package.HexDump(internalBuffer)}");
}
} while (destination.Position < destination.Length);
}
foreach (var msg in messages)
{
msg.DatagramSequenceNumber = batch.DatagramSequenceNumber;
msg.OrderingChannel = batch.OrderingChannel;
msg.OrderingIndex = batch.OrderingIndex;
HandlePackage(msg);
msg.PutPool();
}
}
private void HandleSplitMessage(PlayerNetworkSession playerSession, ConnectedPackage package, SplitPartPackage splitMessage)
{
int spId = package._splitPacketId;
int spIdx = package._splitPacketIndex;
int spCount = package._splitPacketCount;
if (!playerSession.Splits.ContainsKey(spId))
{
playerSession.Splits.Add(spId, new SplitPartPackage[spCount]);
}
SplitPartPackage[] spPackets = playerSession.Splits[spId];
spPackets[spIdx] = splitMessage;
bool haveEmpty = false;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
MemoryStream stream = new MemoryStream();
for (int i = 0; i < spPackets.Length; i++)
{
SplitPartPackage splitPartPackage = spPackets[i];
byte[] buf = splitPartPackage.Message;
stream.Write(buf, 0, buf.Length);
splitPartPackage.PutPool();
}
playerSession.Splits.Remove(spId);
byte[] buffer = stream.ToArray();
Package fullMessage = PackageFactory.CreatePackage(buffer[0], buffer) ?? new UnknownPackage(buffer[0], buffer);
fullMessage.DatagramSequenceNumber = package._datagramSequenceNumber;
fullMessage.OrderingChannel = package._orderingChannel;
fullMessage.OrderingIndex = package._orderingIndex;
HandlePackage(fullMessage);
fullMessage.PutPool();
}
}
// Main -- Fill a priority queue with packages, then remove a random number of them
static void Main()
{
Console.WriteLine("Create a priority queue:");
PriorityQueue <Package> pq = new PriorityQueue <Package>();
Console.WriteLine("Add a random number (0 - 20) of random packages to the queue:");
Package pack;
PackageFactory fact = new PackageFactory();
// Generate a random number less than 20
Random rand = new Random();
int numToCreate = rand.Next(20); // Random int from 0 - 20
Console.WriteLine("\tCreating {0} packages: ", numToCreate);
for (int i = 0; i < numToCreate; i++)
{
Console.Write("\t\tGenerating and adding random package {0}", i);
pack = fact.CreatePackage();
Console.WriteLine(" with priority {0}", pack.Priority);
pq.Enqueue(pack);
}
Console.WriteLine("See what we got:");
int total = pq.Count;
Console.WriteLine("Packages received: {0}", total);
Console.WriteLine("Remove a random number of packages (0 - 20): ");
int numToRemove = rand.Next(20);
Console.WriteLine("\tRemoving up to {0} packages", numToRemove);
for (int i = 0; i < numToRemove; i++)
{
pack = pq.Dequeue();
if (pack != null)
{
Console.WriteLine("\t\tShipped package with priority {0}",
pack.Priority);
}
}
// See how many were shipped
Console.WriteLine("Shipped {0} packages", total - pq.Count);
}
private List <Package> HandleBatch(McpeWrapper batch)
{
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
Console.WriteLine("Package:\n" + Package.HexDump(payload));
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
destination.Position = 0;
NbtBinaryReader reader = new NbtBinaryReader(destination, true);
int len = reader.ReadInt32();
byte[] internalBuffer = reader.ReadBytes(len);
Console.WriteLine($"Package [len={len}:\n" + Package.HexDump(internalBuffer));
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer, "mcpe") ?? new UnknownPackage(internalBuffer[0], internalBuffer));
if (destination.Length > destination.Position)
{
throw new Exception("Have more data");
}
}
return(messages);
}
public static async Task CreateNewShipment(NewShipmentRequest request)
{
try
{
var package = PackageFactory.CreatePackage(request.PackageData);
await PackageEntity.ValidateNew(package);
var shipment = ShipmentFactory.CreateShipment(request);
await ShipmentEntity.ValidateNew(shipment);
await PackageUseCases.RegisterPackage.Execute(package);
await ShipmentUseCases.RegisterShipment.Execute(shipment);
await ShipmentUseCases.Set.PackageId(shipment.Id.ToString(), package.Id.ToString());
await ShipmentUseCases.UpdateShipmentWithBoundry(shipment);
}
catch (Exception e)
{
throw;
}
}
private void NewPackage()
{
if (SaveIfRequired())
{
ItemSelector selector = new ItemSelector();
selector.Initialize(PackageFactory.GetPackageList().ToList <object>(), "Package Type");
if (selector.ShowIfMultiple() == DialogResult.OK && selector.SelectedItem != null)
{
BaseChangePackage pkg = PackageFactory.CreatePackage((BaseChangePackage)selector.SelectedItem);
pkg.HasUnsavedChanges = false;
ComponentControl ac = new ComponentControl();
pkg.Name = "New Change Package";
ac.Setup(pkg, "Package Properties");
if (ac.ShowDialog() == DialogResult.OK)
{
ac.UpdateComponent(pkg);
Package = pkg;
}
}
}
}
public void TestRealDecrytp()
{
// YFtS5MGIU/UQ2w2n3RdqMoBcHOzqEQqISOyKD+W9Prk=
using (RijndaelManaged rijAlg = new RijndaelManaged())
{
rijAlg.BlockSize = 128;
rijAlg.Padding = PaddingMode.None;
rijAlg.Mode = CipherMode.CFB;
rijAlg.FeedbackSize = 8;
rijAlg.Key = Base64Url.Decode("Tv9JFj4vhftDXgcjpNWNocWZrVKaVpF+icEh51M8MvI=");
rijAlg.IV = rijAlg.Key.Take(16).ToArray();
Assert.AreEqual(rijAlg.Key.Take(16).ToArray(), rijAlg.IV);
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream())
{
byte[] buffer1 = SoapHexBinary.Parse("172e0592aba239d86b7ca2384cfad4e4fa5b883ff6db73931ecd").Value;
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
msDecrypt.Write(buffer1, 0, buffer1.Length);
msDecrypt.Position = 0;
byte[] checksum;
byte[] clearBytes;
using (var clearBuffer = new MemoryStream())
{
var buffer = new byte[1024];
var read = csDecrypt.Read(buffer, 0, buffer.Length);
while (read > 0)
{
clearBuffer.Write(buffer, 0, read);
read = csDecrypt.Read(buffer, 0, buffer.Length);
}
csDecrypt.Flush();
var fullResult = clearBuffer.ToArray();
clearBytes = (byte[])fullResult.Take(fullResult.Length - 8).ToArray();
checksum = fullResult.Skip(fullResult.Length - 8).ToArray();
}
Assert.AreEqual(6, clearBytes[0]);
Package message = PackageFactory.CreatePackage(clearBytes[0], clearBytes, "mcpe");
Assert.NotNull(message);
Assert.AreEqual(typeof(McpeWrapper), message.GetType());
List <Package> messages = HandleBatch((McpeWrapper)message);
McpeClientToServerHandshake magic = (McpeClientToServerHandshake)messages.FirstOrDefault();
Assert.AreEqual(typeof(McpeClientToServerHandshake), magic?.GetType());
//Hashing - Checksum - Validation
MemoryStream hashStream = new MemoryStream();
Assert.True(BitConverter.IsLittleEndian);
hashStream.Write(BitConverter.GetBytes(0L), 0, 8);
hashStream.Write(clearBytes, 0, clearBytes.Length);
hashStream.Write(rijAlg.Key, 0, rijAlg.Key.Length);
SHA256Managed crypt = new SHA256Managed();
var hashBuffer = hashStream.ToArray();
byte[] validationCheckSum = crypt.ComputeHash(hashBuffer, 0, hashBuffer.Length).Take(8).ToArray();
Assert.AreEqual(checksum, validationCheckSum);
}
}
}
}
internal void HandlePackage(Package message, PlayerNetworkSession playerSession)
{
if (message == null)
{
return;
}
TraceReceive(message);
if (typeof(UnknownPackage) == message.GetType())
{
UnknownPackage packet = (UnknownPackage)message;
Log.Warn($"Received unknown package 0x{message.Id:X2}\n{Package.HexDump(packet.Message)}");
return;
}
if (typeof(McpeBatch) == message.GetType())
{
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = MiNetServer.MemoryStreamManager.GetStream();
defStream2.CopyTo(destination);
destination.Position = 0;
NbtBinaryReader reader = new NbtBinaryReader(destination, true);
int len = reader.ReadInt32();
byte[] internalBuffer = reader.ReadBytes(len);
//byte[] internalBuffer = destination.ToArray();
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
if (destination.Length > destination.Position)
{
throw new Exception("Have more data");
}
}
foreach (var msg in messages)
{
msg.DatagramSequenceNumber = batch.DatagramSequenceNumber;
msg.OrderingChannel = batch.OrderingChannel;
msg.OrderingIndex = batch.OrderingIndex;
HandlePackage(msg, playerSession);
msg.PutPool();
}
return;
}
Player player = playerSession.Player;
if (player != null)
{
player.HandlePackage(message);
}
}
public NodeNetworkHandler(MiNetServer server, Player player, TcpClient client)
{
_server = server;
_player = player;
_client = client;
new Thread(() =>
{
try
{
_server.ServerInfo.PlayerSessions.TryAdd((IPEndPoint)_client.Client.RemoteEndPoint, null);
Log.Debug("RemoteNetworkHandler waiting for a connection... " + _client.Client.RemoteEndPoint);
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
//_client = _listener.AcceptTcpClient();
Log.Debug("RemoteNetworkHandler got a proxy connection... ");
NetworkStream stream = _client.GetStream();
BinaryReader reader = new BinaryReader(stream);
_writer = new BinaryWriter(new BufferedStream(stream, _client.SendBufferSize));
while (true)
{
if (_client == null)
{
return;
}
// Get a stream object for reading and writing
try
{
int packageNs = reader.ReadByte();
int len = reader.ReadInt32();
byte[] bytes = reader.ReadBytes(len);
Package message = null;
if (packageNs == 0)
{
message = PackageFactory.CreatePackage(bytes[0], bytes, "mcpe");
}
else if (packageNs == 1)
{
message = PackageFactory.CreatePackage(bytes[0], bytes, "ftl");
}
if (message == null)
{
Log.Error($"Bad parse of message");
}
else
{
message.Timer.Restart();
Log.Debug($"Got message {message.GetType().Name}");
if (_server != null)
{
ServerInfo serverInfo = _server.ServerInfo;
Interlocked.Increment(ref serverInfo.NumberOfPacketsInPerSecond);
}
//FastThreadPool.QueueUserWorkItem(() =>
//{
HandlePackage(message);
message.PutPool();
//});
}
}
catch (Exception)
{
try
{
_player.Disconnect("Lost connection", false);
}
catch (Exception)
{
_client = null;
}
}
}
}
catch (Exception e)
{
}
})
{
IsBackground = true
}.Start();
}
/// <summary>
/// Processes a message.
/// </summary>
/// <param name="receiveBytes">The received bytes.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
/// <exception cref="System.Exception">Receive ERROR, NAK in wrong place</exception>
private void ProcessMessage(byte[] receiveBytes, IPEndPoint senderEndpoint)
{
byte msgId = receiveBytes[0];
if (msgId <= (byte)DefaultMessageIdTypes.ID_USER_PACKET_ENUM)
{
DefaultMessageIdTypes msgIdType = (DefaultMessageIdTypes)msgId;
Package message = PackageFactory.CreatePackage(msgId, receiveBytes);
if (message == null)
{
return;
}
TraceReceive(message);
switch (msgIdType)
{
case DefaultMessageIdTypes.ID_UNCONNECTED_PONG:
{
UnconnectedPong incoming = (UnconnectedPong)message;
HaveServer = true;
SendOpenConnectionRequest1();
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REPLY_1:
{
OpenConnectionReply1 incoming = (OpenConnectionReply1)message;
_mtuSize = incoming.mtuSize;
//if (incoming.mtuSize < _mtuSize) throw new Exception("Error:" + incoming.mtuSize);
SendOpenConnectionRequest2();
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REPLY_2:
{
OpenConnectionReply2 incoming = (OpenConnectionReply2)message;
//_mtuSize = incoming.mtuSize;
SendConnectionRequest();
break;
}
}
}
else
{
DatagramHeader header = new DatagramHeader(receiveBytes[0]);
if (!header.isACK && !header.isNAK && header.isValid)
{
if (receiveBytes[0] == 0xa0)
{
throw new Exception("Receive ERROR, NAK in wrong place");
}
//ConnectedPackage package = ConnectedPackage.CreateObject();
ConnectedPackage package = new ConnectedPackage();
package.Decode(receiveBytes);
header = package._datagramHeader;
//Log.Debug(">\tReceive Datagram #" + package._datagramSequenceNumber.IntValue());
Log.Debug($"> Datagram #{header.datagramSequenceNumber}, {package._hasSplit}, {package._splitPacketId}, {package._reliability}, {package._reliableMessageNumber}, {package._sequencingIndex}, {package._orderingChannel}, {package._orderingIndex}");
var messages = package.Messages;
//Reliability reliability = package._reliability;
//if (reliability == Reliability.Reliable
// || reliability == Reliability.ReliableSequenced
// || reliability == Reliability.ReliableOrdered
// )
{
if (header.datagramSequenceNumber == 1000)
{
Log.Error("Datagram 1000 ignored");
}
else
{
// Send ACK
Acks ack = new Acks();
ack.acks.Add(package._datagramSequenceNumber.IntValue());
byte[] data = ack.Encode();
//Log.Info("Send ACK #" + package._datagramSequenceNumber.IntValue());
SendData(data, senderEndpoint);
}
}
//if (LoginSent) return; //HACK
foreach (var message in messages)
{
if (message is SplitPartPackage)
{
lock (Session.SyncRoot)
{
HandleSplitMessage(Session, package, (SplitPartPackage)message);
}
continue;
}
message.Timer.Restart();
HandlePackage(message);
message.PutPool();
}
//package.PutPool();
}
else if (header.isPacketPair)
{
Log.Warn("header.isPacketPair");
}
else if (header.isACK && header.isValid)
{
HandleAck(receiveBytes, senderEndpoint);
}
else if (header.isNAK && header.isValid)
{
Nak nak = new Nak();
nak.Decode(receiveBytes);
HandleNak(receiveBytes, senderEndpoint);
}
else if (!header.isValid)
{
Log.Warn("!!!! ERROR, Invalid header !!!!!");
}
else
{
Log.Warn("!! WHAT THE F");
}
}
}
/// <summary>
/// Handles the specified package.
/// </summary>
/// <param name="message">The package.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
private void HandlePackage(Package message, IPEndPoint senderEndpoint)
{
if (typeof(McpeBatch) == message.GetType())
{
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
byte[] internalBuffer = destination.ToArray();
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
}
foreach (var msg in messages)
{
HandlePackage(msg, senderEndpoint);
}
return;
}
TraceReceive(message);
if (typeof(UnknownPackage) == message.GetType())
{
return;
}
if (typeof(McpeDisconnect) == message.GetType())
{
McpeDisconnect msg = (McpeDisconnect)message;
Log.Debug(msg.message);
StopServer();
return;
}
if (typeof(ConnectedPing) == message.GetType())
{
ConnectedPing msg = (ConnectedPing)message;
SendConnectedPong(msg.sendpingtime);
return;
}
if (typeof(McpeFullChunkData) == message.GetType())
{
McpeFullChunkData msg = (McpeFullChunkData)message;
ChunkColumn chunk = ClientUtils.DecocedChunkColumn(msg.chunkData);
if (chunk != null)
{
Log.DebugFormat("Chunk X={0}", chunk.x);
Log.DebugFormat("Chunk Z={0}", chunk.z);
ClientUtils.SaveChunkToAnvil(chunk);
}
return;
}
if (typeof(ConnectionRequestAccepted) == message.GetType())
{
Thread.Sleep(50);
SendNewIncomingConnection();
var t1 = new Timer(state => SendConnectedPing(), null, 2000, 5000);
Thread.Sleep(50);
SendLogin("Client12");
return;
}
if (typeof(McpeSetSpawnPosition) == message.GetType())
{
McpeSetSpawnPosition msg = (McpeSetSpawnPosition)message;
_spawn = new Vector3(msg.x, msg.y, msg.z);
_level.SpawnX = (int)_spawn.X;
_level.SpawnY = (int)_spawn.Y;
_level.SpawnZ = (int)_spawn.Z;
return;
}
if (typeof(McpeStartGame) == message.GetType())
{
McpeStartGame msg = (McpeStartGame)message;
_entityId = msg.entityId;
_spawn = new Vector3(msg.x, msg.y, msg.z);
_level.LevelName = "Default";
_level.Version = 19133;
_level.GameType = msg.gamemode;
ClientUtils.SaveLevel(_level);
return;
}
if (typeof(McpeTileEvent) == message.GetType())
{
McpeTileEvent msg = (McpeTileEvent)message;
Log.DebugFormat("X: {0}", msg.x);
Log.DebugFormat("Y: {0}", msg.y);
Log.DebugFormat("Z: {0}", msg.z);
Log.DebugFormat("Case 1: {0}", msg.case1);
Log.DebugFormat("Case 2: {0}", msg.case2);
return;
}
if (typeof(McpeAddEntity) == message.GetType())
{
McpeAddEntity msg = (McpeAddEntity)message;
Log.DebugFormat("Entity ID: {0}", msg.entityId);
Log.DebugFormat("Entity Type: {0}", msg.entityType);
Log.DebugFormat("X: {0}", msg.x);
Log.DebugFormat("Y: {0}", msg.y);
Log.DebugFormat("Z: {0}", msg.z);
Log.DebugFormat("Yaw: {0}", msg.yaw);
Log.DebugFormat("Pitch: {0}", msg.pitch);
Log.DebugFormat("Velocity X: {0}", msg.speedX);
Log.DebugFormat("Velocity Y: {0}", msg.speedY);
Log.DebugFormat("Velocity Z: {0}", msg.speedZ);
Log.DebugFormat("Metadata: {0}", msg.metadata.ToString());
Log.DebugFormat("Links count: {0}", msg.links);
return;
}
if (typeof(McpeSetEntityData) == message.GetType())
{
McpeSetEntityData msg = (McpeSetEntityData)message;
Log.DebugFormat("Entity ID: {0}", msg.entityId);
MetadataDictionary metadata = msg.metadata;
Log.DebugFormat("Metadata: {0}", metadata.ToString());
return;
}
if (typeof(McpeMovePlayer) == message.GetType())
{
McpeMovePlayer msg = (McpeMovePlayer)message;
Log.DebugFormat("Entity ID: {0}", msg.entityId);
_currentLocation = new PlayerLocation(msg.x, msg.y + 10, msg.z);
SendMcpeMovePlayer();
return;
}
if (typeof(McpeUpdateBlock) == message.GetType())
{
McpeUpdateBlock msg = (McpeUpdateBlock)message;
Log.DebugFormat("No of Blocks: {0}", msg.blocks.Count);
return;
}
if (typeof(McpeLevelEvent) == message.GetType())
{
McpeLevelEvent msg = (McpeLevelEvent)message;
Log.DebugFormat("Event ID: {0}", msg.eventId);
Log.DebugFormat("X: {0}", msg.x);
Log.DebugFormat("Y: {0}", msg.y);
Log.DebugFormat("Z: {0}", msg.z);
Log.DebugFormat("Data: {0}", msg.data);
return;
}
}
protected override void DecodePackage()
{
Messages = new List <Package>();
_buffer.Position = 0;
_datagramHeader = new DatagramHeader(ReadByte());
_datagramSequenceNumber = ReadLittle();
_datagramHeader.datagramSequenceNumber = _datagramSequenceNumber;
while (_buffer.Position < _buffer.Length)
{
byte flags = ReadByte();
_reliability = (Reliability)((flags & Convert.ToByte("011100000", 2)) >> 5);
_hasSplit = ((flags & Convert.ToByte("00010000", 2)) > 0);
short dataBitLength = ReadShort();
if (_reliability == Reliability.Reliable ||
_reliability == Reliability.ReliableSequenced ||
_reliability == Reliability.ReliableOrdered
)
{
_reliableMessageNumber = ReadLittle();
}
else
{
_reliableMessageNumber = -1;
}
if (_reliability == Reliability.UnreliableSequenced ||
_reliability == Reliability.ReliableSequenced
)
{
_sequencingIndex = ReadLittle();
}
if (_reliability == Reliability.UnreliableSequenced ||
_reliability == Reliability.ReliableSequenced ||
_reliability == Reliability.ReliableOrdered ||
_reliability == Reliability.ReliableOrderedWithAckReceipt
)
{
_orderingIndex = ReadLittle();
_orderingChannel = ReadByte(); // flags
}
else
{
_orderingIndex = 0;
_orderingChannel = 0;
}
if (_hasSplit)
{
_splitPacketCount = ReadInt();
_splitPacketId = ReadShort();
_splitPacketIndex = ReadInt();
}
else
{
_splitPacketCount = -1;
_splitPacketId = -1;
_splitPacketIndex = -1;
}
// Slurp the payload
MessageLength = (int)Math.Ceiling((((double)dataBitLength) / 8));
byte[] internalBuffer = ReadBytes(MessageLength);
if (_hasSplit)
{
//Log.Debug("Recieve split\n" + HexDump(internalBuffer));
SplitPartPackage splitPartPackage = SplitPartPackage.CreateObject();
splitPartPackage.Id = internalBuffer[0];
splitPartPackage.Message = internalBuffer;
Messages.Add(splitPartPackage);
return;
}
byte id = internalBuffer[0];
if (id == 0x8e)
{
id = internalBuffer[1];
}
Package package = PackageFactory.CreatePackage(id, internalBuffer) ?? new UnknownPackage(id, internalBuffer);
package.DatagramSequenceNumber = _datagramSequenceNumber;
package.ReliableMessageNumber = _reliableMessageNumber;
package.OrderingChannel = _orderingChannel;
package.OrderingIndex = _orderingIndex;
if (!(package is McpeBatch))
{
Log.Debug($"Raw: {package.DatagramSequenceNumber} {package.ReliableMessageNumber} {package.OrderingIndex} {package.GetType().Name} 0x{package.Id:x2} \n{HexDump(internalBuffer)}");
}
Messages.Add(package);
if (MessageLength != internalBuffer.Length)
{
Debug.WriteLine("Missmatch of requested lenght, and actual read lenght");
}
}
}
private void HandleRakNetMessage(byte[] receiveBytes, IPEndPoint senderEndpoint, byte msgId)
{
DefaultMessageIdTypes msgIdType = (DefaultMessageIdTypes)msgId;
// Increase fast, decrease slow on 1s ticks.
if (ServerInfo.NumberOfPlayers < ServerInfo.PlayerSessions.Count)
{
ServerInfo.NumberOfPlayers = ServerInfo.PlayerSessions.Count;
}
// Shortcut to reply fast, and no parsing
if (msgIdType == DefaultMessageIdTypes.ID_OPEN_CONNECTION_REQUEST_1)
{
if (!GreylistManager.AcceptConnection(senderEndpoint.Address))
{
var noFree = NoFreeIncomingConnections.CreateObject();
var bytes = noFree.Encode();
noFree.PutPool();
TraceSend(noFree);
SendData(bytes, senderEndpoint);
Interlocked.Increment(ref ServerInfo.NumberOfDeniedConnectionRequestsPerSecond);
return;
}
}
Package message = null;
try
{
try
{
message = PackageFactory.CreatePackage(msgId, receiveBytes, "raknet");
}
catch (Exception)
{
message = null;
}
if (message == null)
{
GreylistManager.Blacklist(senderEndpoint.Address);
Log.ErrorFormat("Receive bad packet with ID: {0} (0x{0:x2}) {2} from {1}", msgId, senderEndpoint.Address, (DefaultMessageIdTypes)msgId);
return;
}
TraceReceive(message);
switch (msgIdType)
{
case DefaultMessageIdTypes.ID_UNCONNECTED_PING:
case DefaultMessageIdTypes.ID_UNCONNECTED_PING_OPEN_CONNECTIONS:
{
HandleRakNetMessage(senderEndpoint, (UnconnectedPing)message);
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REQUEST_1:
{
HandleRakNetMessage(senderEndpoint, (OpenConnectionRequest1)message);
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REQUEST_2:
{
HandleRakNetMessage(senderEndpoint, (OpenConnectionRequest2)message);
break;
}
default:
GreylistManager.Blacklist(senderEndpoint.Address);
Log.ErrorFormat("Receive unexpected packet with ID: {0} (0x{0:x2}) {2} from {1}", msgId, senderEndpoint.Address, (DefaultMessageIdTypes)msgId);
break;
}
}
finally
{
if (message != null)
{
message.PutPool();
}
}
}
/// <summary>
/// Processes a message.
/// </summary>
/// <param name="receiveBytes">The received bytes.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
/// <exception cref="System.Exception">Receive ERROR, NAK in wrong place</exception>
private void ProcessMessage(byte[] receiveBytes, IPEndPoint senderEndpoint)
{
byte msgId = receiveBytes[0];
if (msgId == 0xFE)
{
Log.WarnFormat("A query detected from: {0}", senderEndpoint.Address);
HandleQuery(receiveBytes, senderEndpoint);
}
else if (msgId <= (byte)DefaultMessageIdTypes.ID_USER_PACKET_ENUM)
{
DefaultMessageIdTypes msgIdType = (DefaultMessageIdTypes)msgId;
Package message = PackageFactory.CreatePackage(msgId, receiveBytes);
TraceReceive(message);
switch (msgIdType)
{
case DefaultMessageIdTypes.ID_UNCONNECTED_PING:
case DefaultMessageIdTypes.ID_UNCONNECTED_PING_OPEN_CONNECTIONS:
{
UnconnectedPing incoming = (UnconnectedPing)message;
//TODO: This needs to be verified with RakNet first
//response.sendpingtime = msg.sendpingtime;
//response.sendpongtime = DateTimeOffset.UtcNow.Ticks / TimeSpan.TicksPerMillisecond;
var packet = new UnconnectedPong
{
serverId = 22345,
pingId = incoming.pingId /*incoming.pingId*/,
serverName = string.Format(@"MCPE;{0};27;0.11.1;{1};{2}", Motd, _playerSessions.Count, 1000)
};
var data = packet.Encode();
TraceSend(packet);
SendData(data, senderEndpoint, _listener);
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REQUEST_1:
{
OpenConnectionRequest1 incoming = (OpenConnectionRequest1)message;
_isPerformanceTest = _isPerformanceTest || incoming.raknetProtocolVersion == byte.MaxValue;
var packet = new OpenConnectionReply1
{
serverGuid = 12345,
mtuSize = incoming.mtuSize,
serverHasSecurity = 0
};
var data = packet.Encode();
TraceSend(packet);
SendData(data, senderEndpoint, _listener);
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REQUEST_2:
{
OpenConnectionRequest2 incoming = (OpenConnectionRequest2)message;
Log.WarnFormat("New connection from: {0} {1}", senderEndpoint.Address, incoming.clientUdpPort);
var packet = new OpenConnectionReply2
{
serverGuid = 12345,
mtuSize = incoming.mtuSize,
doSecurityAndHandshake = new byte[0]
};
PlayerNetworkSession session = null;
lock (_playerSessions)
{
if (_playerSessions.ContainsKey(senderEndpoint))
{
PlayerNetworkSession value;
_playerSessions.TryRemove(senderEndpoint, out value);
value.Player.HandleDisconnectionNotification();
Log.Info("Removed ghost");
}
session = new PlayerNetworkSession(new Player(this, senderEndpoint, _levels[_random.Next(0, _levels.Count)], _pluginManager, incoming.mtuSize), senderEndpoint);
session.LastUpdatedTime = DateTime.UtcNow;
session.Mtuize = incoming.mtuSize;
_playerSessions.TryAdd(senderEndpoint, session);
}
var data = packet.Encode();
TraceSend(packet);
SendData(data, senderEndpoint, session.SyncRoot);
break;
}
default:
Log.ErrorFormat("Receive unexpected packet with ID: {0} (0x{0:x2}) from {1}", msgId, senderEndpoint.Address);
break;
}
if (message != null)
{
message.PutPool();
}
else
{
Log.ErrorFormat("Receive unexpected packet with ID: {0} (0x{0:x2}) from {1}", msgId, senderEndpoint.Address);
}
}
else
{
DatagramHeader header = new DatagramHeader(receiveBytes[0]);
if (!header.isACK && !header.isNAK && header.isValid)
{
if (receiveBytes[0] == 0xa0)
{
throw new Exception("Receive ERROR, NAK in wrong place");
}
ConnectedPackage package = ConnectedPackage.CreateObject();
package.Decode(receiveBytes);
List <Package> messages = package.Messages;
if (messages.Count == 1)
{
McpeBatch batch = messages.First() as McpeBatch;
if (batch != null)
{
messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
byte[] internalBuffer = destination.ToArray();
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
}
}
}
// IF reliable code below is enabled, useItem start sending doubles
// for some unknown reason.
//Reliability reliability = package._reliability;
//if (reliability == Reliability.Reliable
// || reliability == Reliability.ReliableSequenced
// || reliability == Reliability.ReliableOrdered
// )
{
EnqueueAck(senderEndpoint, package._datagramSequenceNumber);
}
PlayerNetworkSession playerSession;
if (_playerSessions.TryGetValue(senderEndpoint, out playerSession))
{
foreach (var message in messages)
{
if (message is SplitPartPackage)
{
SplitPartPackage splitMessage = message as SplitPartPackage;
int spId = package._splitPacketId;
int spIdx = package._splitPacketIndex;
int spCount = package._splitPacketCount;
if (!playerSession.Splits.ContainsKey(spId))
{
playerSession.Splits.Add(spId, new SplitPartPackage[spCount]);
}
SplitPartPackage[] spPackets = playerSession.Splits[spId];
spPackets[spIdx] = splitMessage;
bool haveEmpty = false;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
MemoryStream stream = new MemoryStream();
for (int i = 0; i < spPackets.Length; i++)
{
byte[] buf = spPackets[i].Message;
stream.Write(buf, 0, buf.Length);
}
byte[] buffer = stream.ToArray();
var fullMessage = PackageFactory.CreatePackage(buffer[0], buffer) ?? new UnknownPackage(buffer[0], buffer);
HandlePackage(fullMessage, playerSession);
}
continue;
}
message.Timer.Restart();
HandlePackage(message, playerSession);
message.PutPool();
}
}
package.PutPool();
}
else if (header.isACK && header.isValid)
{
HandleAck(receiveBytes, senderEndpoint);
}
else if (header.isNAK && header.isValid)
{
HandleNak(receiveBytes, senderEndpoint);
}
else if (!header.isValid)
{
Log.Warn("!!!! ERROR, Invalid header !!!!!");
}
}
}
internal void HandlePackage(Package message, PlayerNetworkSession playerSession)
{
Player player = playerSession.Player;
if (message == null)
{
return;
}
if (typeof(McpeWrapper) == message.GetType())
{
McpeWrapper batch = (McpeWrapper)message;
// Get bytes
byte[] payload = batch.payload;
if (playerSession.CryptoContext != null && Config.GetProperty("UseEncryption", true))
{
payload = CryptoUtils.Decrypt(payload, playerSession.CryptoContext);
}
//if (Log.IsDebugEnabled)
// Log.Debug($"0x{payload[0]:x2}\n{Package.HexDump(payload)}");
var msg = PackageFactory.CreatePackage(payload[0], payload, "mcpe") ?? new UnknownPackage(payload[0], payload);
HandlePackage(msg, playerSession);
msg.PutPool();
return;
}
if (typeof(UnknownPackage) == message.GetType())
{
UnknownPackage packet = (UnknownPackage)message;
Log.Warn($"Received unknown package 0x{message.Id:X2}\n{Package.HexDump(packet.Message)}");
return;
}
if (typeof(McpeBatch) == message.GetType())
{
Log.Debug("Handle MCPE batch message");
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = MiNetServer.MemoryStreamManager.GetStream();
defStream2.CopyTo(destination);
destination.Position = 0;
NbtBinaryReader reader = new NbtBinaryReader(destination, true);
while (destination.Position < destination.Length)
{
int len = reader.ReadInt32();
byte[] internalBuffer = reader.ReadBytes(len);
//if (Log.IsDebugEnabled)
// Log.Debug($"0x{internalBuffer[0]:x2}\n{Package.HexDump(internalBuffer)}");
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer, "mcpe") ?? new UnknownPackage(internalBuffer[0], internalBuffer));
}
if (destination.Length > destination.Position)
{
throw new Exception("Have more data");
}
}
foreach (var msg in messages)
{
msg.DatagramSequenceNumber = batch.DatagramSequenceNumber;
msg.OrderingChannel = batch.OrderingChannel;
msg.OrderingIndex = batch.OrderingIndex;
HandlePackage(msg, playerSession);
msg.PutPool();
}
return;
}
if (player != null)
{
player.HandlePackage(message);
}
}
protected override void DecodePackage()
{
Messages = new List <Package>();
_buffer.Position = 0;
_datagramHeader = new DatagramHeader(ReadByte());
_datagramSequenceNumber = ReadLittle();
while (_buffer.Position != _buffer.Length)
{
byte flags = ReadByte();
_reliability = (Reliability)((flags & Convert.ToByte("011100000", 2)) >> 5);
int hasSplitPacket = ((flags & Convert.ToByte("00010000", 2)) >> 0);
short dataBitLength = ReadShort();
if (_reliability == Reliability.Reliable ||
_reliability == Reliability.ReliableSequenced ||
_reliability == Reliability.ReliableOrdered
)
{
_reliableMessageNumber = ReadLittle();
}
else
{
_reliableMessageNumber = -1;
}
if (_reliability == Reliability.UnreliableSequenced ||
_reliability == Reliability.ReliableSequenced
)
{
_sequencingIndex = ReadLittle();
}
if (_reliability == Reliability.UnreliableSequenced ||
_reliability == Reliability.ReliableSequenced ||
_reliability == Reliability.ReliableOrdered ||
_reliability == Reliability.ReliableOrderedWithAckReceipt
)
{
_orderingIndex = ReadLittle();
_orderingChannel = ReadByte(); // flags
}
else
{
_orderingChannel = 0;
}
if (hasSplitPacket != 0)
{
_splitPacketCount = ReadInt();
_splitPacketId = ReadShort();
_splitPacketIndex = ReadInt();
}
else
{
_splitPacketCount = 0;
}
// Slurp the payload
MessageLength = (int)Math.Ceiling((((double)dataBitLength) / 8));
byte[] internalBuffer = ReadBytes(MessageLength);
if (hasSplitPacket != 0)
{
Messages.Add(new SplitPartPackage(internalBuffer[0], internalBuffer));
return;
}
Messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
if (MessageLength != internalBuffer.Length)
{
Debug.WriteLine("Missmatch of requested lenght, and actual read lenght");
}
}
}
/// <summary>
/// Processes a message.
/// </summary>
/// <param name="receiveBytes">The received bytes.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
/// <exception cref="System.Exception">Receive ERROR, NAK in wrong place</exception>
private void ProcessMessage(byte[] receiveBytes, IPEndPoint senderEndpoint)
{
byte msgId = receiveBytes[0];
//Log.DebugFormat("Recieve {0} 0x{0:x2} len: {1}", msgId, receiveBytes.Length);
if (msgId <= (byte)DefaultMessageIdTypes.ID_USER_PACKET_ENUM)
{
DefaultMessageIdTypes msgIdType = (DefaultMessageIdTypes)msgId;
Package message = PackageFactory.CreatePackage(msgId, receiveBytes);
if (message == null)
{
return;
}
TraceReceive(message);
switch (msgIdType)
{
case DefaultMessageIdTypes.ID_UNCONNECTED_PONG:
{
UnconnectedPong incoming = (UnconnectedPong)message;
SendOpenConnectionRequest1();
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REPLY_1:
{
OpenConnectionReply1 incoming = (OpenConnectionReply1)message;
_mtuSize = incoming.mtuSize;
//if (incoming.mtuSize < _mtuSize) throw new Exception("Error:" + incoming.mtuSize);
SendOpenConnectionRequest2();
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REPLY_2:
{
OpenConnectionReply2 incoming = (OpenConnectionReply2)message;
//_mtuSize = incoming.mtuSize;
SendConnectionRequest();
break;
}
}
}
else
{
DatagramHeader header = new DatagramHeader(receiveBytes[0]);
if (!header.isACK && !header.isNAK && header.isValid)
{
if (receiveBytes[0] == 0xa0)
{
throw new Exception("Receive ERROR, NAK in wrong place");
}
//ConnectedPackage package = ConnectedPackage.CreateObject();
ConnectedPackage package = new ConnectedPackage();
package.Decode(receiveBytes);
//Log.Debug(">\tReceive Datagram #" + package._datagramSequenceNumber.IntValue());
var messages = package.Messages;
//Reliability reliability = package._reliability;
//if (reliability == Reliability.Reliable
// || reliability == Reliability.ReliableSequenced
// || reliability == Reliability.ReliableOrdered
// )
{
// Send ACK
Acks ack = new Acks();
ack.acks.Add(package._datagramSequenceNumber.IntValue());
byte[] data = ack.Encode();
//Log.Info("Send ACK #" + package._datagramSequenceNumber.IntValue());
SendData(data, senderEndpoint);
}
//if (LoginSent) return; //HACK
foreach (var message in messages)
{
if (message is SplitPartPackage)
{
lock (Session.SyncRoot)
{
var splits = Session.Splits;
SplitPartPackage splitMessage = message as SplitPartPackage;
int spId = package._splitPacketId;
int spIdx = package._splitPacketIndex;
int spCount = package._splitPacketCount;
Log.DebugFormat("Got split package {2} (of {0}) for split ID: {1}", spCount, spId, spIdx);
if (!splits.ContainsKey(spId))
{
splits.Add(spId, new SplitPartPackage[spCount]);
}
SplitPartPackage[] spPackets = splits[spId];
if (spIdx < 0 || spIdx >= spPackets.Length)
{
Log.DebugFormat("Unexpeted split package {2} (of {0}) for split ID: {1}", spCount, spId, spIdx);
continue;
}
if (splitMessage.Message == null)
{
Log.DebugFormat("Empty split package");
continue;
}
spPackets[spIdx] = splitMessage;
bool haveEmpty = false;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
MemoryStream stream = new MemoryStream();
for (int i = 0; i < spPackets.Length; i++)
{
byte[] buf = spPackets[i].Message;
stream.Write(buf, 0, buf.Length);
}
try
{
byte[] buffer = stream.ToArray();
Log.DebugFormat("Processing split-message 0x{1:x2}, lenght={0}", buffer.Length, buffer[0]);
Package fullMessage = PackageFactory.CreatePackage(buffer[0], buffer) ?? new UnknownPackage(buffer[0], buffer);
HandlePackage(fullMessage, senderEndpoint);
fullMessage.PutPool();
continue;
}
catch (Exception e)
{
Log.Error("When processing split-message", e);
}
}
message.PutPool();
continue;
}
}
else
{
message.Timer.Restart();
HandlePackage(message, senderEndpoint);
message.PutPool();
}
}
//package.PutPool();
}
else if (header.isPacketPair)
{
Log.Warn("header.isPacketPair");
}
else if (header.isACK && header.isValid)
{
HandleAck(receiveBytes, senderEndpoint);
}
else if (header.isNAK && header.isValid)
{
Nak nak = new Nak();
nak.Decode(receiveBytes);
Log.Warn("!!!! NAK !!!!!" + nak.sequenceNumber.IntValue());
HandleNak(receiveBytes, senderEndpoint);
}
else if (!header.isValid)
{
Log.Warn("!!!! ERROR, Invalid header !!!!!");
}
else
{
Log.Warn("!! WHAT THE F");
}
}
}
private void HandleSplitMessage(PlayerNetworkSession playerSession, SplitPartPackage splitMessage)
{
int spId = splitMessage.SplitId;
int spIdx = splitMessage.SplitIdx;
int spCount = splitMessage.SplitCount;
Int24 sequenceNumber = splitMessage.DatagramSequenceNumber;
Reliability reliability = splitMessage.Reliability;
Int24 reliableMessageNumber = splitMessage.ReliableMessageNumber;
Int24 orderingIndex = splitMessage.OrderingIndex;
byte orderingChannel = splitMessage.OrderingChannel;
SplitPartPackage[] spPackets;
bool haveEmpty = false;
// Need sync for this part since they come very fast, and very close in time.
// If no synk, will often detect complete message two times (or more).
lock (playerSession.Splits)
{
if (!playerSession.Splits.ContainsKey(spId))
{
playerSession.Splits.TryAdd(spId, new SplitPartPackage[spCount]);
}
spPackets = playerSession.Splits[spId];
if (spPackets[spIdx] != null)
{
Log.Debug("Already had splitpart (resent). Ignore this part.");
return;
}
spPackets[spIdx] = splitMessage;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
SplitPartPackage[] waste;
playerSession.Splits.TryRemove(spId, out waste);
using (MemoryStream stream = MemoryStreamManager.GetStream())
{
for (int i = 0; i < spPackets.Length; i++)
{
SplitPartPackage splitPartPackage = spPackets[i];
byte[] buf = splitPartPackage.Message;
if (buf == null)
{
Log.Error("Expected bytes in splitpart, but got none");
continue;
}
stream.Write(buf, 0, buf.Length);
splitPartPackage.PutPool();
}
byte[] buffer = stream.ToArray();
try
{
ConnectedPackage newPackage = ConnectedPackage.CreateObject();
newPackage._datagramSequenceNumber = sequenceNumber;
newPackage._reliability = reliability;
newPackage._reliableMessageNumber = reliableMessageNumber;
newPackage._orderingIndex = orderingIndex;
newPackage._orderingChannel = (byte)orderingChannel;
newPackage._hasSplit = false;
Package fullMessage = PackageFactory.CreatePackage(buffer[0], buffer, "raknet") ??
new UnknownPackage(buffer[0], buffer);
fullMessage.DatagramSequenceNumber = sequenceNumber;
fullMessage.Reliability = reliability;
fullMessage.ReliableMessageNumber = reliableMessageNumber;
fullMessage.OrderingIndex = orderingIndex;
fullMessage.OrderingChannel = orderingChannel;
newPackage.Messages = new List <Package>();
newPackage.Messages.Add(fullMessage);
Log.Debug(
$"Assembled split package {newPackage._reliability} message #{newPackage._reliableMessageNumber}, Chan: #{newPackage._orderingChannel}, OrdIdx: #{newPackage._orderingIndex}");
HandleConnectedPackage(playerSession, newPackage);
newPackage.PutPool();
}
catch (Exception e)
{
Log.Error("Error during split message parsing", e);
if (Log.IsDebugEnabled)
{
Log.Debug($"0x{buffer[0]:x2}\n{Package.HexDump(buffer)}");
}
playerSession.Disconnect("Bad package received from client.", false);
}
}
}
}
/// <summary>
/// Handles the specified package.
/// </summary>
/// <param name="message">The package.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
private void HandlePackage(Package message, IPEndPoint senderEndpoint)
{
if (typeof(McpeBatch) == message.GetType())
{
Log.Debug("Processing Batch package");
McpeBatch batch = (McpeBatch)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
MemoryStream destination = new MemoryStream();
defStream2.CopyTo(destination);
destination.Position = 0;
NbtBinaryReader reader = new NbtBinaryReader(destination, true);
do
{
int len = reader.ReadInt32();
byte[] internalBuffer = reader.ReadBytes(len);
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer) ?? new UnknownPackage(internalBuffer[0], internalBuffer));
} while (destination.Position < destination.Length); // throw new Exception("Have more data");
}
foreach (var msg in messages)
{
HandlePackage(msg, senderEndpoint);
msg.PutPool();
}
return;
}
TraceReceive(message);
if (typeof(UnknownPackage) == message.GetType())
{
return;
}
if (typeof(McpeDisconnect) == message.GetType())
{
McpeDisconnect msg = (McpeDisconnect)message;
Log.InfoFormat("Disconnect {1}: {0}", msg.message, Username);
SendDisconnectionNotification();
StopClient();
return;
}
if (typeof(ConnectedPing) == message.GetType())
{
ConnectedPing msg = (ConnectedPing)message;
SendConnectedPong(msg.sendpingtime);
return;
}
if (typeof(McpeFullChunkData) == message.GetType())
{
//McpeFullChunkData msg = (McpeFullChunkData) message;
//ChunkColumn chunk = ClientUtils.DecocedChunkColumn(msg.chunkData);
//if (chunk != null)
//{
// Log.DebugFormat("Chunk X={0}", chunk.x);
// Log.DebugFormat("Chunk Z={0}", chunk.z);
// //ClientUtils.SaveChunkToAnvil(chunk);
//}
return;
}
if (typeof(ConnectionRequestAccepted) == message.GetType())
{
Thread.Sleep(50);
SendNewIncomingConnection();
//_connectedPingTimer = new Timer(state => SendConnectedPing(), null, 1000, 1000);
Thread.Sleep(50);
SendLogin(Username);
return;
}
if (typeof(McpeSetSpawnPosition) == message.GetType())
{
McpeSetSpawnPosition msg = (McpeSetSpawnPosition)message;
_spawn = new Vector3(msg.x, msg.y, msg.z);
_level.SpawnX = (int)_spawn.X;
_level.SpawnY = (int)_spawn.Y;
_level.SpawnZ = (int)_spawn.Z;
return;
}
if (typeof(McpeStartGame) == message.GetType())
{
McpeStartGame msg = (McpeStartGame)message;
_entityId = msg.entityId;
_spawn = new Vector3(msg.x, msg.y, msg.z);
_level.LevelName = "Default";
_level.Version = 19133;
_level.GameType = msg.gamemode;
//ClientUtils.SaveLevel(_level);
return;
}
if (typeof(McpeTileEvent) == message.GetType())
{
McpeTileEvent msg = (McpeTileEvent)message;
Log.DebugFormat("X: {0}", msg.x);
Log.DebugFormat("Y: {0}", msg.y);
Log.DebugFormat("Z: {0}", msg.z);
Log.DebugFormat("Case 1: {0}", msg.case1);
Log.DebugFormat("Case 2: {0}", msg.case2);
return;
}
if (typeof(McpeAddEntity) == message.GetType())
{
McpeAddEntity msg = (McpeAddEntity)message;
Log.DebugFormat("Entity ID: {0}", msg.entityId);
Log.DebugFormat("Entity Type: {0}", msg.entityType);
Log.DebugFormat("X: {0}", msg.x);
Log.DebugFormat("Y: {0}", msg.y);
Log.DebugFormat("Z: {0}", msg.z);
Log.DebugFormat("Yaw: {0}", msg.yaw);
Log.DebugFormat("Pitch: {0}", msg.pitch);
Log.DebugFormat("Velocity X: {0}", msg.speedX);
Log.DebugFormat("Velocity Y: {0}", msg.speedY);
Log.DebugFormat("Velocity Z: {0}", msg.speedZ);
//Log.DebugFormat("Metadata: {0}", msg.metadata.ToString());
//Log.DebugFormat("Links count: {0}", msg.links);
return;
}
if (typeof(McpeSetEntityData) == message.GetType())
{
McpeSetEntityData msg = (McpeSetEntityData)message;
Log.DebugFormat("Entity ID: {0}", msg.entityId);
MetadataDictionary metadata = msg.metadata;
Log.DebugFormat("Metadata: {0}", metadata.ToString());
return;
}
if (typeof(McpeMovePlayer) == message.GetType())
{
//McpeMovePlayer msg = (McpeMovePlayer) message;
//Log.DebugFormat("Entity ID: {0}", msg.entityId);
//CurrentLocation = new PlayerLocation(msg.x, msg.y + 10, msg.z);
//SendMcpeMovePlayer();
return;
}
if (typeof(McpeUpdateBlock) == message.GetType())
{
McpeUpdateBlock msg = (McpeUpdateBlock)message;
Log.DebugFormat("No of Blocks: {0}", msg.blocks.Count);
return;
}
if (typeof(McpeLevelEvent) == message.GetType())
{
McpeLevelEvent msg = (McpeLevelEvent)message;
Log.DebugFormat("Event ID: {0}", msg.eventId);
Log.DebugFormat("X: {0}", msg.x);
Log.DebugFormat("Y: {0}", msg.y);
Log.DebugFormat("Z: {0}", msg.z);
Log.DebugFormat("Data: {0}", msg.data);
return;
}
if (typeof(McpeContainerSetContent) == message.GetType())
{
McpeContainerSetContent msg = (McpeContainerSetContent)message;
Log.DebugFormat("Window ID: 0x{0:x2}, Count: {1}", msg.windowId, msg.slotData.Count);
var slots = msg.slotData.GetValues();
foreach (var entry in slots)
{
MetadataSlot slot = (MetadataSlot)entry;
//Log.DebugFormat(" - Id: {0}, Metadata: {1}, Count: {2}", slot.Value.Item.Id, slot.Value.Item.Metadata, slot.Value.Count);
}
return;
}
if (typeof(McpeCraftingData) == message.GetType())
{
string fileName = Path.GetTempPath() + "Recipes_" + Guid.NewGuid() + ".txt";
Log.Info("Writing recipes to filename: " + fileName);
FileStream file = File.OpenWrite(fileName);
McpeCraftingData msg = (McpeCraftingData)message;
IndentedTextWriter writer = new IndentedTextWriter(new StreamWriter(file));
writer.WriteLine("static RecipeManager()");
writer.WriteLine("{");
writer.Indent++;
writer.WriteLine("Recipes = new Recipes");
writer.WriteLine("{");
writer.Indent++;
foreach (Recipe recipe in msg.recipes)
{
ShapelessRecipe shapelessRecipe = recipe as ShapelessRecipe;
if (shapelessRecipe != null)
{
writer.WriteLine(string.Format("new ShapelessRecipe(new ItemStack(ItemFactory.GetItem({0}, {1}), {2}),", shapelessRecipe.Result.Id, shapelessRecipe.Result.Metadata, shapelessRecipe.Result.Count));
writer.Indent++;
writer.WriteLine("new List<ItemStack>");
writer.WriteLine("{");
writer.Indent++;
foreach (var itemStack in shapelessRecipe.Input)
{
writer.WriteLine(string.Format("new ItemStack(ItemFactory.GetItem({0}, {1}), {2}),", itemStack.Id, itemStack.Metadata, itemStack.Count));
}
writer.Indent--;
writer.WriteLine("}),");
writer.Indent--;
continue;
}
ShapedRecipe shapedRecipe = recipe as ShapedRecipe;
if (shapedRecipe != null)
{
writer.WriteLine(string.Format("new ShapedRecipe({0}, {1}, new ItemStack(ItemFactory.GetItem({2}, {3}), {4}),", shapedRecipe.Width, shapedRecipe.Height, shapedRecipe.Result.Id, shapedRecipe.Result.Metadata, shapedRecipe.Result.Count));
writer.Indent++;
writer.WriteLine("new Item[]");
writer.WriteLine("{");
writer.Indent++;
foreach (Item item in shapedRecipe.Input)
{
writer.WriteLine(string.Format("ItemFactory.GetItem({0}, {1}),", item.Id, item.Metadata));
}
writer.Indent--;
writer.WriteLine("}),");
writer.Indent--;
continue;
}
}
writer.WriteLine("};");
writer.Indent--;
writer.WriteLine("}");
writer.Indent--;
writer.Flush();
file.Close();
Environment.Exit(0);
return;
}
}
internal void HandlePackage(Package message, PlayerNetworkSession playerSession)
{
//SignalTick();
try
{
if (message == null)
{
return;
}
if (typeof(UnknownPackage) == message.GetType())
{
UnknownPackage packet = (UnknownPackage)message;
if (Log.IsDebugEnabled)
{
Log.Warn($"Received unknown package 0x{message.Id:X2}\n{Package.HexDump(packet.Message)}");
}
message.PutPool();
return;
}
if (typeof(McpeWrapper) == message.GetType())
{
McpeWrapper batch = (McpeWrapper)message;
var messages = new List <Package>();
// Get bytes
byte[] payload = batch.payload;
if (playerSession.CryptoContext != null && playerSession.CryptoContext.UseEncryption)
{
throw new Exception("No crypto enabled");
}
// Decompress bytes
MemoryStream stream = new MemoryStream(payload);
if (stream.ReadByte() != 0x78)
{
throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C");
}
stream.ReadByte();
using (var defStream2 = new DeflateStream(stream, CompressionMode.Decompress, false))
{
// Get actual package out of bytes
using (MemoryStream destination = MiNetServer.MemoryStreamManager.GetStream())
{
defStream2.CopyTo(destination);
destination.Position = 0;
NbtBinaryReader reader = new NbtBinaryReader(destination, true);
while (destination.Position < destination.Length)
{
//int len = reader.ReadInt32();
int len = BatchUtils.ReadLength(destination);
byte[] internalBuffer = reader.ReadBytes(len);
//if (Log.IsDebugEnabled)
// Log.Debug($"0x{internalBuffer[0]:x2}\n{Package.HexDump(internalBuffer)}");
messages.Add(PackageFactory.CreatePackage(internalBuffer[0], internalBuffer, "mcpe") ??
new UnknownPackage(internalBuffer[0], internalBuffer));
}
if (destination.Length > destination.Position)
{
throw new Exception("Have more data");
}
}
}
foreach (var msg in messages)
{
// Temp fix for performance, take 1.
var interact = msg as McpeInteract;
if (interact?.actionId == 4 && interact.targetRuntimeEntityId == 0)
{
continue;
}
msg.DatagramSequenceNumber = batch.DatagramSequenceNumber;
msg.Reliability = batch.Reliability;
msg.ReliableMessageNumber = batch.ReliableMessageNumber;
msg.OrderingChannel = batch.OrderingChannel;
msg.OrderingIndex = batch.OrderingIndex;
HandlePackage(msg, playerSession);
}
message.PutPool();
return;
}
MiNetServer.TraceReceive(message);
if (CryptoContext != null && CryptoContext.UseEncryption)
{
MiNetServer.FastThreadPool.QueueUserWorkItem(delegate()
{
HandlePackage(MessageHandler, message as Package);
message.PutPool();
});
}
else
{
HandlePackage(MessageHandler, message);
message.PutPool();
}
}
catch (Exception e)
{
Log.Error("Package handling", e);
throw;
}
}
/// <summary>
/// Processes a message.
/// </summary>
/// <param name="receiveBytes">The received bytes.</param>
/// <param name="senderEndpoint">The sender's endpoint.</param>
/// <exception cref="System.Exception">Receive ERROR, NAK in wrong place</exception>
private void ProcessMessage(byte[] receiveBytes, IPEndPoint senderEndpoint)
{
//_serverEndpoint = senderEndpoint;
byte msgId = receiveBytes[0];
if (msgId <= (byte)DefaultMessageIdTypes.ID_USER_PACKET_ENUM)
{
DefaultMessageIdTypes msgIdType = (DefaultMessageIdTypes)msgId;
Package message = PackageFactory.CreatePackage(msgId, receiveBytes);
if (message == null)
{
return;
}
TraceReceive(message);
switch (msgIdType)
{
case DefaultMessageIdTypes.ID_UNCONNECTED_PONG:
{
//Thread.Sleep(50);
UnconnectedPong incoming = (UnconnectedPong)message;
SendOpenConnectionRequest1();
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REPLY_1:
{
//Thread.Sleep(50);
OpenConnectionReply1 incoming = (OpenConnectionReply1)message;
if (incoming.mtuSize < _mtuSize)
{
throw new Exception("Error:" + incoming.mtuSize);
}
SendOpenConnectionRequest2();
break;
}
case DefaultMessageIdTypes.ID_OPEN_CONNECTION_REPLY_2:
{
OpenConnectionReply2 incoming = (OpenConnectionReply2)message;
//Thread.Sleep(50);
//_mtuSize = incoming.mtuSize;
SendConnectionRequest();
break;
}
case DefaultMessageIdTypes.ID_CONNECTION_REQUEST_ACCEPTED:
{
//Thread.Sleep(50);
SendNewIncomingConnection();
var t1 = new Timer(state => SendConnectedPing(), null, 0, 5000);
//Thread.Sleep(50);
SendLogin("Client12");
break;
}
}
}
else
{
DatagramHeader header = new DatagramHeader(receiveBytes[0]);
if (!header.isACK && !header.isNAK && header.isValid)
{
if (receiveBytes[0] == 0xa0)
{
throw new Exception("Receive ERROR, NAK in wrong place");
}
ConnectedPackage package = ConnectedPackage.CreateObject();
package.Decode(receiveBytes);
Log.Debug(">\tReceive Datagram #" + package._datagramSequenceNumber.IntValue());
var messages = package.Messages;
//Log.Debug("Received package: #" + package._datagramSequenceNumber.IntValue());
Reliability reliability = package._reliability;
//Log.InfoFormat("Reliability: {0}", reliability);
//if (reliability == Reliability.Reliable
// || reliability == Reliability.ReliableSequenced
// || reliability == Reliability.ReliableOrdered
// )
{
// Send ACK
Acks ack = new Acks();
ack.acks.Add(package._datagramSequenceNumber.IntValue());
byte[] data = ack.Encode();
//Log.Debug("<\tSend ACK on #" + package._datagramSequenceNumber.IntValue());
SendData(data, senderEndpoint);
}
foreach (var message in messages)
{
if (message is SplitPartPackage)
{
SplitPartPackage splitMessage = message as SplitPartPackage;
int spId = package._splitPacketId;
int spIdx = package._splitPacketIndex;
int spCount = package._splitPacketCount;
Log.DebugFormat("Got split package {2} (of {0}) for split ID: {1}", spCount, spId, spIdx);
if (!_splits.ContainsKey(spId))
{
_splits[spId] = new SplitPartPackage[spCount];
}
else
{
Log.WarnFormat("Resent split package {2} (of {0}) for split ID: {1}", spCount, spId, spIdx);
}
SplitPartPackage[] spPackets = _splits[spId];
spPackets[spIdx] = splitMessage;
bool haveEmpty = false;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
if (!haveEmpty)
{
Log.WarnFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
MemoryStream stream = new MemoryStream();
for (int i = 0; i < spPackets.Length; i++)
{
byte[] buf = spPackets[i].Message;
stream.Write(buf, 0, buf.Length);
}
try
{
byte[] buffer = stream.ToArray();
var fullMessage = PackageFactory.CreatePackage(buffer[0], buffer) ?? new UnknownPackage(buffer[0], buffer);
Log.Debug("Processing split-message");
HandlePackage(fullMessage, senderEndpoint);
fullMessage.PutPool();
}
catch (Exception e)
{
Log.Warn("When processing split-message", e);
}
}
message.PutPool();
return;
}
{
message.Timer.Restart();
HandlePackage(message, senderEndpoint);
//message.PutPool();
}
}
//package.PutPool();
}
else if (header.isPacketPair)
{
Log.Warn("header.isPacketPair");
}
else if (header.isACK && header.isValid)
{
HandleAck(receiveBytes, senderEndpoint);
}
else if (header.isNAK && header.isValid)
{
Nak nak = new Nak();
nak.Decode(receiveBytes);
Log.Warn("!!!! NAK !!!!!" + nak.sequenceNumber.IntValue());
HandleNak(receiveBytes, senderEndpoint);
}
else if (!header.isValid)
{
Log.Warn("!!!! ERROR, Invalid header !!!!!");
}
else
{
Log.Warn("!! WHAT THE F");
}
}
}
